diff --git a/configure.ac b/configure.ac
index 977543b9..5e927486 100644
--- a/configure.ac
+++ b/configure.ac
@@ -93,6 +93,8 @@ AC_LANG([C++])
 # Check pkg-config is available
 PKG_PROG_PKG_CONFIG([0.20])
 
+CXXFLAGS="-std=c++11 $CXXFLAGS"
+
 # Check static build is requested
 if test "x$ARIA2_STATIC" = "xyes"; then
   case "$host" in
diff --git a/src/AbstractAuthResolver.cc b/src/AbstractAuthResolver.cc
index 2b273cb9..a9730f3d 100644
--- a/src/AbstractAuthResolver.cc
+++ b/src/AbstractAuthResolver.cc
@@ -42,13 +42,13 @@ AbstractAuthResolver::AbstractAuthResolver() {}
 AbstractAuthResolver::~AbstractAuthResolver() {}
 
 void AbstractAuthResolver::setUserDefinedAuthConfig
-(const SharedHandle<AuthConfig>& authConfig)
+(const std::shared_ptr<AuthConfig>& authConfig)
 {
   userDefinedAuthConfig_ = authConfig;
 }
 
 void AbstractAuthResolver::setDefaultAuthConfig
-(const SharedHandle<AuthConfig>& authConfig)
+(const std::shared_ptr<AuthConfig>& authConfig)
 {
   defaultAuthConfig_ = authConfig;
 }
diff --git a/src/AbstractAuthResolver.h b/src/AbstractAuthResolver.h
index 93e73b87..4801490f 100644
--- a/src/AbstractAuthResolver.h
+++ b/src/AbstractAuthResolver.h
@@ -41,24 +41,24 @@ namespace aria2 {
 
 class AbstractAuthResolver : public AuthResolver {
 private:
-  SharedHandle<AuthConfig> userDefinedAuthConfig_;
+  std::shared_ptr<AuthConfig> userDefinedAuthConfig_;
 
-  SharedHandle<AuthConfig> defaultAuthConfig_;
+  std::shared_ptr<AuthConfig> defaultAuthConfig_;
 public:
   AbstractAuthResolver();
 
   virtual ~AbstractAuthResolver();
 
-  void setUserDefinedAuthConfig(const SharedHandle<AuthConfig>& authConfig);
+  void setUserDefinedAuthConfig(const std::shared_ptr<AuthConfig>& authConfig);
 
-  const SharedHandle<AuthConfig>& getUserDefinedAuthConfig() const
+  const std::shared_ptr<AuthConfig>& getUserDefinedAuthConfig() const
   {
     return userDefinedAuthConfig_;
   }
 
-  void setDefaultAuthConfig(const SharedHandle<AuthConfig>& authConfig);
+  void setDefaultAuthConfig(const std::shared_ptr<AuthConfig>& authConfig);
 
-  const SharedHandle<AuthConfig>& getDefaultAuthConfig() const
+  const std::shared_ptr<AuthConfig>& getDefaultAuthConfig() const
   {
     return defaultAuthConfig_;
   }
diff --git a/src/AbstractBtMessage.cc b/src/AbstractBtMessage.cc
index 55177370..f4fef342 100644
--- a/src/AbstractBtMessage.cc
+++ b/src/AbstractBtMessage.cc
@@ -54,7 +54,7 @@ AbstractBtMessage::AbstractBtMessage(uint8_t id, const char* name)
 
 AbstractBtMessage::~AbstractBtMessage() {}
 
-void AbstractBtMessage::setPeer(const SharedHandle<Peer>& peer)
+void AbstractBtMessage::setPeer(const std::shared_ptr<Peer>& peer)
 {
   peer_ = peer;
 }
@@ -67,12 +67,12 @@ void AbstractBtMessage::validate()
 }
 
 void
-AbstractBtMessage::setBtMessageValidator(const SharedHandle<BtMessageValidator>& validator) {
+AbstractBtMessage::setBtMessageValidator(const std::shared_ptr<BtMessageValidator>& validator) {
   validator_ = validator;
 }
 
 void AbstractBtMessage::setPieceStorage
-(const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
diff --git a/src/AbstractBtMessage.h b/src/AbstractBtMessage.h
index c34269e7..49a1b2ed 100644
--- a/src/AbstractBtMessage.h
+++ b/src/AbstractBtMessage.h
@@ -56,9 +56,9 @@ private:
 
   const char* name_;
 
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
 
-  SharedHandle<Peer> peer_;
+  std::shared_ptr<Peer> peer_;
 
   BtMessageDispatcher* dispatcher_;
 
@@ -68,11 +68,11 @@ private:
 
   PeerConnection* peerConnection_;
 
-  SharedHandle<BtMessageValidator> validator_;
+  std::shared_ptr<BtMessageValidator> validator_;
 
   bool metadataGetMode_;
 protected:
-  const SharedHandle<PieceStorage>& getPieceStorage() const
+  const std::shared_ptr<PieceStorage>& getPieceStorage() const
   {
     return pieceStorage_;
   }
@@ -130,12 +130,12 @@ public:
     cuid_ = cuid;
   }
 
-  const SharedHandle<Peer>& getPeer() const
+  const std::shared_ptr<Peer>& getPeer() const
   {
     return peer_;
   }
 
-  void setPeer(const SharedHandle<Peer>& peer);
+  void setPeer(const std::shared_ptr<Peer>& peer);
 
   virtual void doReceivedAction() {}
 
@@ -151,9 +151,9 @@ public:
 
   virtual void onChokingEvent(const BtChokingEvent& event) {}
 
-  void setBtMessageValidator(const SharedHandle<BtMessageValidator>& validator);
+  void setBtMessageValidator(const std::shared_ptr<BtMessageValidator>& validator);
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 
   void setBtMessageDispatcher(BtMessageDispatcher* dispatcher);
 
diff --git a/src/AbstractCommand.cc b/src/AbstractCommand.cc
index 9e253025..bb078495 100644
--- a/src/AbstractCommand.cc
+++ b/src/AbstractCommand.cc
@@ -79,12 +79,12 @@ namespace aria2 {
 
 AbstractCommand::AbstractCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& s,
- const SharedHandle<SocketRecvBuffer>& socketRecvBuffer,
+ const std::shared_ptr<SocketCore>& s,
+ const std::shared_ptr<SocketRecvBuffer>& socketRecvBuffer,
  bool incNumConnection)
   : Command(cuid), checkPoint_(global::wallclock()),
     timeout_(requestGroup->getTimeout()),
@@ -125,7 +125,7 @@ AbstractCommand::~AbstractCommand() {
 }
 
 void AbstractCommand::useFasterRequest
-(const SharedHandle<Request>& fasterRequest)
+(const std::shared_ptr<Request>& fasterRequest)
 {
   A2_LOG_INFO(fmt("CUID#%" PRId64 " - Use faster Request hostname=%s, port=%u",
                   getCuid(),
@@ -180,7 +180,7 @@ bool AbstractCommand::execute() {
       if(req_ && fileEntry_->countPooledRequest() > 0 &&
          requestGroup_->getTotalLength()-requestGroup_->getCompletedLength()
          < calculateMinSplitSize()*2) {
-        SharedHandle<Request> fasterRequest = fileEntry_->findFasterRequest(req_);
+        std::shared_ptr<Request> fasterRequest = fileEntry_->findFasterRequest(req_);
         if(fasterRequest) {
           useFasterRequest(fasterRequest);
           return true;
@@ -197,7 +197,7 @@ bool AbstractCommand::execute() {
         if(getOption()->getAsBool(PREF_SELECT_LEAST_USED_HOST)) {
           getDownloadEngine()->getRequestGroupMan()->getUsedHosts(usedHosts);
         }
-        SharedHandle<Request> fasterRequest =
+        std::shared_ptr<Request> fasterRequest =
           fileEntry_->findFasterRequest
           (req_, usedHosts, e_->getRequestGroupMan()->getServerStatMan());
         if(fasterRequest) {
@@ -230,7 +230,7 @@ bool AbstractCommand::execute() {
           size_t maxSegments = req_?req_->getMaxPipelinedRequest():1;
           size_t minSplitSize = calculateMinSplitSize();
           while(segments_.size() < maxSegments) {
-            SharedHandle<Segment> segment =
+            std::shared_ptr<Segment> segment =
               getSegmentMan()->getSegment(getCuid(), minSplitSize);
             if(!segment) {
               break;
@@ -276,7 +276,7 @@ bool AbstractCommand::execute() {
     } else {
       if(checkPoint_.difference(global::wallclock()) >= timeout_) {
         // timeout triggers ServerStat error state.
-        SharedHandle<ServerStat> ss =
+        std::shared_ptr<ServerStat> ss =
           e_->getRequestGroupMan()->getOrCreateServerStat(req_->getHost(),
                                                           req_->getProtocol());
         ss->setError();
@@ -375,7 +375,7 @@ bool AbstractCommand::execute() {
 
 void AbstractCommand::tryReserved() {
   if(getDownloadContext()->getFileEntries().size() == 1) {
-    const SharedHandle<FileEntry>& entry =
+    const std::shared_ptr<FileEntry>& entry =
       getDownloadContext()->getFirstFileEntry();
     // Don't create new command if currently file length is unknown
     // and there are no URI left. Because file length is unknown, we
@@ -490,7 +490,7 @@ void AbstractCommand::disableReadCheckSocket() {
 }
 
 void AbstractCommand::setReadCheckSocket
-(const SharedHandle<SocketCore>& socket) {
+(const std::shared_ptr<SocketCore>& socket) {
   if(!socket->isOpen()) {
     disableReadCheckSocket();
   } else {
@@ -509,7 +509,7 @@ void AbstractCommand::setReadCheckSocket
 }
 
 void AbstractCommand::setReadCheckSocketIf
-(const SharedHandle<SocketCore>& socket, bool pred)
+(const std::shared_ptr<SocketCore>& socket, bool pred)
 {
   if(pred) {
     setReadCheckSocket(socket);
@@ -527,7 +527,7 @@ void AbstractCommand::disableWriteCheckSocket() {
 }
 
 void AbstractCommand::setWriteCheckSocket
-(const SharedHandle<SocketCore>& socket) {
+(const std::shared_ptr<SocketCore>& socket) {
   if(!socket->isOpen()) {
     disableWriteCheckSocket();
   } else {
@@ -546,7 +546,7 @@ void AbstractCommand::setWriteCheckSocket
 }
 
 void AbstractCommand::setWriteCheckSocketIf
-(const SharedHandle<SocketCore>& socket, bool pred)
+(const std::shared_ptr<SocketCore>& socket, bool pred)
 {
   if(pred) {
     setWriteCheckSocket(socket);
@@ -555,7 +555,7 @@ void AbstractCommand::setWriteCheckSocketIf
   }
 }
 
-void AbstractCommand::swapSocket(SharedHandle<SocketCore>& socket)
+void AbstractCommand::swapSocket(std::shared_ptr<SocketCore>& socket)
 {
   disableReadCheckSocket();
   disableWriteCheckSocket();
@@ -634,7 +634,7 @@ namespace {
 // Returns true if proxy is defined for the given protocol. Otherwise
 // returns false.
 bool isProxyRequest
-(const std::string& protocol, const SharedHandle<Option>& option)
+(const std::string& protocol, const std::shared_ptr<Option>& option)
 {
   std::string proxyUri = getProxyUri(protocol, option.get());
   return !proxyUri.empty();
@@ -642,7 +642,7 @@ bool isProxyRequest
 } // namespace
 
 namespace {
-bool inNoProxy(const SharedHandle<Request>& req,
+bool inNoProxy(const std::shared_ptr<Request>& req,
                const std::string& noProxy)
 {
   std::vector<Scip> entries;
@@ -685,9 +685,9 @@ bool AbstractCommand::isProxyDefined() const
     !inNoProxy(req_, getOption()->get(PREF_NO_PROXY));
 }
 
-SharedHandle<Request> AbstractCommand::createProxyRequest() const
+std::shared_ptr<Request> AbstractCommand::createProxyRequest() const
 {
-  SharedHandle<Request> proxyRequest;
+  std::shared_ptr<Request> proxyRequest;
   if(inNoProxy(req_, getOption()->get(PREF_NO_PROXY))) {
     return proxyRequest;
   }
@@ -772,7 +772,7 @@ std::string AbstractCommand::resolveHostname
 }
 
 void AbstractCommand::prepareForNextAction
-(const SharedHandle<CheckIntegrityEntry>& checkEntry)
+(const std::shared_ptr<CheckIntegrityEntry>& checkEntry)
 {
   std::vector<Command*>* commands = new std::vector<Command*>();
   auto_delete_container<std::vector<Command*> > commandsDel(commands);
@@ -783,7 +783,7 @@ void AbstractCommand::prepareForNextAction
 }
 
 bool AbstractCommand::checkIfConnectionEstablished
-(const SharedHandle<SocketCore>& socket,
+(const std::shared_ptr<SocketCore>& socket,
  const std::string& connectedHostname,
  const std::string& connectedAddr,
  uint16_t connectedPort)
@@ -827,7 +827,7 @@ const std::string& AbstractCommand::resolveProxyMethod
   }
 }
 
-const SharedHandle<Option>& AbstractCommand::getOption() const
+const std::shared_ptr<Option>& AbstractCommand::getOption() const
 {
   return requestGroup_->getOption();
 }
@@ -846,7 +846,7 @@ int32_t AbstractCommand::calculateMinSplitSize() const
   }
 }
 
-void AbstractCommand::setRequest(const SharedHandle<Request>& request)
+void AbstractCommand::setRequest(const std::shared_ptr<Request>& request)
 {
   req_ = request;
 }
@@ -856,27 +856,27 @@ void AbstractCommand::resetRequest()
   req_.reset();
 }
 
-void AbstractCommand::setFileEntry(const SharedHandle<FileEntry>& fileEntry)
+void AbstractCommand::setFileEntry(const std::shared_ptr<FileEntry>& fileEntry)
 {
   fileEntry_ = fileEntry;
 }
 
-void AbstractCommand::setSocket(const SharedHandle<SocketCore>& s)
+void AbstractCommand::setSocket(const std::shared_ptr<SocketCore>& s)
 {
   socket_ = s;
 }
 
-const SharedHandle<DownloadContext>& AbstractCommand::getDownloadContext() const
+const std::shared_ptr<DownloadContext>& AbstractCommand::getDownloadContext() const
 {
   return requestGroup_->getDownloadContext();
 }
 
-const SharedHandle<SegmentMan>& AbstractCommand::getSegmentMan() const
+const std::shared_ptr<SegmentMan>& AbstractCommand::getSegmentMan() const
 {
   return requestGroup_->getSegmentMan();
 }
 
-const SharedHandle<PieceStorage>& AbstractCommand::getPieceStorage() const
+const std::shared_ptr<PieceStorage>& AbstractCommand::getPieceStorage() const
 {
   return requestGroup_->getPieceStorage();
 }
diff --git a/src/AbstractCommand.h b/src/AbstractCommand.h
index ac97b819..a8204b75 100644
--- a/src/AbstractCommand.h
+++ b/src/AbstractCommand.h
@@ -39,8 +39,8 @@
 
 #include <vector>
 #include <string>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimerA2.h"
 
 namespace aria2 {
@@ -68,76 +68,76 @@ private:
   time_t timeout_;
 
   RequestGroup* requestGroup_;
-  SharedHandle<Request> req_;
-  SharedHandle<FileEntry> fileEntry_;
+  std::shared_ptr<Request> req_;
+  std::shared_ptr<FileEntry> fileEntry_;
   DownloadEngine* e_;
-  SharedHandle<SocketCore> socket_;
-  SharedHandle<SocketRecvBuffer> socketRecvBuffer_;
-  std::vector<SharedHandle<Segment> > segments_;
+  std::shared_ptr<SocketCore> socket_;
+  std::shared_ptr<SocketRecvBuffer> socketRecvBuffer_;
+  std::vector<std::shared_ptr<Segment> > segments_;
 
 #ifdef ENABLE_ASYNC_DNS
-  SharedHandle<AsyncNameResolverMan> asyncNameResolverMan_;
+  std::shared_ptr<AsyncNameResolverMan> asyncNameResolverMan_;
 #endif // ENABLE_ASYNC_DNS
 
   bool checkSocketIsReadable_;
   bool checkSocketIsWritable_;
-  SharedHandle<SocketCore> readCheckTarget_;
-  SharedHandle<SocketCore> writeCheckTarget_;
+  std::shared_ptr<SocketCore> readCheckTarget_;
+  std::shared_ptr<SocketCore> writeCheckTarget_;
 
   bool incNumConnection_;
   Timer serverStatTimer_;
 
   int32_t calculateMinSplitSize() const;
-  void useFasterRequest(const SharedHandle<Request>& fasterRequest);
+  void useFasterRequest(const std::shared_ptr<Request>& fasterRequest);
 public:
   RequestGroup* getRequestGroup() const
   {
     return requestGroup_;
   }
 
-  const SharedHandle<Request>& getRequest() const
+  const std::shared_ptr<Request>& getRequest() const
   {
     return req_;
   }
 
-  void setRequest(const SharedHandle<Request>& request);
+  void setRequest(const std::shared_ptr<Request>& request);
 
   // Resets request_. This method is more efficient than
-  // setRequest(SharedHandle<Request>());
+  // setRequest(std::shared_ptr<Request>());
   void resetRequest();
 
-  const SharedHandle<FileEntry>& getFileEntry() const
+  const std::shared_ptr<FileEntry>& getFileEntry() const
   {
     return fileEntry_;
   }
 
-  void setFileEntry(const SharedHandle<FileEntry>& fileEntry);
+  void setFileEntry(const std::shared_ptr<FileEntry>& fileEntry);
 
   DownloadEngine* getDownloadEngine() const
   {
     return e_;
   }
 
-  const SharedHandle<SocketCore>& getSocket() const
+  const std::shared_ptr<SocketCore>& getSocket() const
   {
     return socket_;
   }
 
-  SharedHandle<SocketCore>& getSocket()
+  std::shared_ptr<SocketCore>& getSocket()
   {
     return socket_;
   }
 
-  void setSocket(const SharedHandle<SocketCore>& s);
+  void setSocket(const std::shared_ptr<SocketCore>& s);
 
   void createSocket();
 
-  const SharedHandle<SocketRecvBuffer>& getSocketRecvBuffer() const
+  const std::shared_ptr<SocketRecvBuffer>& getSocketRecvBuffer() const
   {
     return socketRecvBuffer_;
   }
 
-  const std::vector<SharedHandle<Segment> >& getSegments() const
+  const std::vector<std::shared_ptr<Segment> >& getSegments() const
   {
     return segments_;
   }
@@ -152,8 +152,8 @@ public:
 
   void tryReserved();
 
-  void setReadCheckSocket(const SharedHandle<SocketCore>& socket);
-  void setWriteCheckSocket(const SharedHandle<SocketCore>& socket);
+  void setReadCheckSocket(const std::shared_ptr<SocketCore>& socket);
+  void setWriteCheckSocket(const std::shared_ptr<SocketCore>& socket);
   void disableReadCheckSocket();
   void disableWriteCheckSocket();
 
@@ -161,16 +161,16 @@ public:
    * If pred == true, calls setReadCheckSocket(socket). Otherwise, calls
    * disableReadCheckSocket().
    */
-  void setReadCheckSocketIf(const SharedHandle<SocketCore>& socket, bool pred);
+  void setReadCheckSocketIf(const std::shared_ptr<SocketCore>& socket, bool pred);
   /**
    * If pred == true, calls setWriteCheckSocket(socket). Otherwise, calls
    * disableWriteCheckSocket().
    */
-  void setWriteCheckSocketIf(const SharedHandle<SocketCore>& socket, bool pred);
+  void setWriteCheckSocketIf(const std::shared_ptr<SocketCore>& socket, bool pred);
 
   // Swaps socket_ with socket. This disables current read and write
   // check.
-  void swapSocket(SharedHandle<SocketCore>& socket);
+  void swapSocket(std::shared_ptr<SocketCore>& socket);
 
   time_t getTimeout() const
   {
@@ -180,7 +180,7 @@ public:
   void setTimeout(time_t timeout) { timeout_ = timeout; }
 
   void prepareForNextAction
-  (const SharedHandle<CheckIntegrityEntry>& checkEntry);
+  (const std::shared_ptr<CheckIntegrityEntry>& checkEntry);
 
   // Check if socket is connected. If socket is not connected and
   // there are other addresses to try, command is created using
@@ -188,7 +188,7 @@ public:
   // DownloadEngine and returns false. If no addresses left, DlRetryEx
   // exception is thrown.
   bool checkIfConnectionEstablished
-  (const SharedHandle<SocketCore>& socket,
+  (const std::shared_ptr<SocketCore>& socket,
    const std::string& connectedHostname,
    const std::string& connectedAddr,
    uint16_t connectedPort);
@@ -201,19 +201,19 @@ public:
 
   /*
    * Creates Request object for proxy URI and returns it.
-   * If no valid proxy is defined, then returns SharedHandle<Request>().
+   * If no valid proxy is defined, then returns std::shared_ptr<Request>().
    */
-  SharedHandle<Request> createProxyRequest() const;
+  std::shared_ptr<Request> createProxyRequest() const;
 
   // Returns proxy method for given protocol. Either V_GET or V_TUNNEL
   // is returned.  For HTTPS, always returns V_TUNNEL.
   const std::string& resolveProxyMethod(const std::string& protocol) const;
 
-  const SharedHandle<Option>& getOption() const;
+  const std::shared_ptr<Option>& getOption() const;
 
-  const SharedHandle<DownloadContext>& getDownloadContext() const;
-  const SharedHandle<SegmentMan>& getSegmentMan() const;
-  const SharedHandle<PieceStorage>& getPieceStorage() const;
+  const std::shared_ptr<DownloadContext>& getDownloadContext() const;
+  const std::shared_ptr<SegmentMan>& getSegmentMan() const;
+  const std::shared_ptr<PieceStorage>& getPieceStorage() const;
 
   Timer& getCheckPoint()
   {
@@ -235,12 +235,12 @@ protected:
 
 public:
   AbstractCommand
-  (cuid_t cuid, const SharedHandle<Request>& req,
-   const SharedHandle<FileEntry>& fileEntry,
+  (cuid_t cuid, const std::shared_ptr<Request>& req,
+   const std::shared_ptr<FileEntry>& fileEntry,
    RequestGroup* requestGroup, DownloadEngine* e,
-   const SharedHandle<SocketCore>& s = SharedHandle<SocketCore>(),
-   const SharedHandle<SocketRecvBuffer>& socketRecvBuffer
-   = SharedHandle<SocketRecvBuffer>(),
+   const std::shared_ptr<SocketCore>& s = std::shared_ptr<SocketCore>(),
+   const std::shared_ptr<SocketRecvBuffer>& socketRecvBuffer
+   = std::shared_ptr<SocketRecvBuffer>(),
    bool incNumConnection = true);
 
   virtual ~AbstractCommand();
diff --git a/src/AbstractHttpServerResponseCommand.cc b/src/AbstractHttpServerResponseCommand.cc
index 5d9d8c11..e83c4c1e 100644
--- a/src/AbstractHttpServerResponseCommand.cc
+++ b/src/AbstractHttpServerResponseCommand.cc
@@ -49,9 +49,9 @@ namespace aria2 {
 
 AbstractHttpServerResponseCommand::AbstractHttpServerResponseCommand
 (cuid_t cuid,
- const SharedHandle<HttpServer>& httpServer,
+ const std::shared_ptr<HttpServer>& httpServer,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& socket)
+ const std::shared_ptr<SocketCore>& socket)
  : Command(cuid),
    e_(e),
    socket_(socket),
@@ -107,20 +107,21 @@ bool AbstractHttpServerResponseCommand::execute()
     }
   } catch(RecoverableException& e) {
     A2_LOG_INFO_EX
-      (fmt("CUID#%"PRId64" - Error occurred while transmitting response body.",
+      (fmt("CUID#%" PRId64
+           " - Error occurred while transmitting response body.",
            getCuid()),
        e);
     return true;
   }
   if(httpServer_->sendBufferIsEmpty()) {
-    A2_LOG_INFO(fmt("CUID#%"PRId64" - HttpServer: all response transmitted.",
+    A2_LOG_INFO(fmt("CUID#%" PRId64 " - HttpServer: all response transmitted.",
                     getCuid()));
     afterSend(httpServer_, e_);
     return true;
   } else {
     if(timeoutTimer_.difference(global::wallclock()) >= 30) {
-      A2_LOG_INFO(fmt("CUID#%"PRId64" - HttpServer: Timeout while trasmitting"
-                      " response.",
+      A2_LOG_INFO(fmt("CUID#%" PRId64
+                      " - HttpServer: Timeout while trasmitting response.",
                       getCuid()));
       return true;
     } else {
diff --git a/src/AbstractHttpServerResponseCommand.h b/src/AbstractHttpServerResponseCommand.h
index 652d6b05..f972da90 100644
--- a/src/AbstractHttpServerResponseCommand.h
+++ b/src/AbstractHttpServerResponseCommand.h
@@ -36,7 +36,9 @@
 #define D_ABSTRACT_HTTP_SERVER_RESPONSE_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "TimerA2.h"
 
 namespace aria2 {
@@ -48,8 +50,8 @@ class HttpServer;
 class AbstractHttpServerResponseCommand : public Command {
 private:
   DownloadEngine* e_;
-  SharedHandle<SocketCore> socket_;
-  SharedHandle<HttpServer> httpServer_;
+  std::shared_ptr<SocketCore> socket_;
+  std::shared_ptr<HttpServer> httpServer_;
   Timer timeoutTimer_;
   bool readCheck_;
   bool writeCheck_;
@@ -61,13 +63,13 @@ protected:
     return e_;
   }
   // Called after content body is completely sent.
-  virtual void afterSend(const SharedHandle<HttpServer>& httpServer,
+  virtual void afterSend(const std::shared_ptr<HttpServer>& httpServer,
                          DownloadEngine* e) = 0;
 public:
   AbstractHttpServerResponseCommand(cuid_t cuid,
-                                    const SharedHandle<HttpServer>& httpServer,
+                                    const std::shared_ptr<HttpServer>& httpServer,
                                     DownloadEngine* e,
-                                    const SharedHandle<SocketCore>& socket);
+                                    const std::shared_ptr<SocketCore>& socket);
 
   virtual ~AbstractHttpServerResponseCommand();
 
diff --git a/src/AbstractProxyRequestCommand.cc b/src/AbstractProxyRequestCommand.cc
index d24475b3..4d511883 100644
--- a/src/AbstractProxyRequestCommand.cc
+++ b/src/AbstractProxyRequestCommand.cc
@@ -51,18 +51,18 @@ namespace aria2 {
 
 AbstractProxyRequestCommand::AbstractProxyRequestCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e,
- const SharedHandle<Request>& proxyRequest,
- const SharedHandle<SocketCore>& s)
+ const std::shared_ptr<Request>& proxyRequest,
+ const std::shared_ptr<SocketCore>& s)
   :
   AbstractCommand(cuid, req, fileEntry, requestGroup, e, s),
   proxyRequest_(proxyRequest),
   httpConnection_
   (new HttpConnection
-   (cuid, s, SharedHandle<SocketRecvBuffer>(new SocketRecvBuffer(s))))
+   (cuid, s, std::shared_ptr<SocketRecvBuffer>(new SocketRecvBuffer(s))))
 {
   setTimeout(getOption()->getAsInt(PREF_CONNECT_TIMEOUT));
   disableReadCheckSocket();
@@ -74,7 +74,7 @@ AbstractProxyRequestCommand::~AbstractProxyRequestCommand() {}
 bool AbstractProxyRequestCommand::executeInternal() {
   //socket->setBlockingMode();
   if(httpConnection_->sendBufferIsEmpty()) {
-    SharedHandle<HttpRequest> httpRequest(new HttpRequest());
+    std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
     httpRequest->setUserAgent(getOption()->get(PREF_USER_AGENT));
     httpRequest->setRequest(getRequest());
     httpRequest->setProxyRequest(proxyRequest_);
diff --git a/src/AbstractProxyRequestCommand.h b/src/AbstractProxyRequestCommand.h
index 6948867a..b54b7d31 100644
--- a/src/AbstractProxyRequestCommand.h
+++ b/src/AbstractProxyRequestCommand.h
@@ -44,29 +44,29 @@ class SocketCore;
 
 class AbstractProxyRequestCommand : public AbstractCommand {
 private:
-  SharedHandle<Request> proxyRequest_;
+  std::shared_ptr<Request> proxyRequest_;
 
-  SharedHandle<HttpConnection> httpConnection_;
+  std::shared_ptr<HttpConnection> httpConnection_;
 protected:
   virtual bool executeInternal();
 
-  const SharedHandle<HttpConnection>& getHttpConnection() const
+  const std::shared_ptr<HttpConnection>& getHttpConnection() const
   {
     return httpConnection_;
   }
 
-  const SharedHandle<Request>& getProxyRequest() const
+  const std::shared_ptr<Request>& getProxyRequest() const
   {
     return proxyRequest_;
   }
 public:
   AbstractProxyRequestCommand(cuid_t cuid,
-                              const SharedHandle<Request>& req,
-                              const SharedHandle<FileEntry>& fileEntry,
+                              const std::shared_ptr<Request>& req,
+                              const std::shared_ptr<FileEntry>& fileEntry,
                               RequestGroup* requestGroup,
                               DownloadEngine* e,
-                              const SharedHandle<Request>& proxyRequest,
-                              const SharedHandle<SocketCore>& s);
+                              const std::shared_ptr<Request>& proxyRequest,
+                              const std::shared_ptr<SocketCore>& s);
 
   virtual ~AbstractProxyRequestCommand();
 
diff --git a/src/AbstractProxyResponseCommand.cc b/src/AbstractProxyResponseCommand.cc
index 32c5bb0e..c490f020 100644
--- a/src/AbstractProxyResponseCommand.cc
+++ b/src/AbstractProxyResponseCommand.cc
@@ -52,19 +52,19 @@ namespace aria2 {
 
 AbstractProxyResponseCommand::AbstractProxyResponseCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
- const SharedHandle<HttpConnection>& httpConnection,
+ const std::shared_ptr<HttpConnection>& httpConnection,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& s)
+ const std::shared_ptr<SocketCore>& s)
   :AbstractCommand(cuid, req, fileEntry, requestGroup, e, s),
    httpConnection_(httpConnection) {}
 
 AbstractProxyResponseCommand::~AbstractProxyResponseCommand() {}
 
 bool AbstractProxyResponseCommand::executeInternal() {
-  SharedHandle<HttpResponse> httpResponse = httpConnection_->receiveResponse();
+  std::shared_ptr<HttpResponse> httpResponse = httpConnection_->receiveResponse();
   if(!httpResponse) {
     // the server has not responded our request yet.
     getDownloadEngine()->addCommand(this);
diff --git a/src/AbstractProxyResponseCommand.h b/src/AbstractProxyResponseCommand.h
index ef4c2b0d..4c85fbcc 100644
--- a/src/AbstractProxyResponseCommand.h
+++ b/src/AbstractProxyResponseCommand.h
@@ -44,23 +44,23 @@ class SocketCore;
 
 class AbstractProxyResponseCommand : public AbstractCommand {
 private:
-  SharedHandle<HttpConnection> httpConnection_;
+  std::shared_ptr<HttpConnection> httpConnection_;
 protected:
   virtual bool executeInternal();
 
-  const SharedHandle<HttpConnection>& getHttpConnection() const
+  const std::shared_ptr<HttpConnection>& getHttpConnection() const
   {
     return httpConnection_;
   }
 public:
   AbstractProxyResponseCommand
   (cuid_t cuid,
-   const SharedHandle<Request>& req,
-   const SharedHandle<FileEntry>& fileEntry,
+   const std::shared_ptr<Request>& req,
+   const std::shared_ptr<FileEntry>& fileEntry,
    RequestGroup* requestGroup,
-   const SharedHandle<HttpConnection>& httpConnection,
+   const std::shared_ptr<HttpConnection>& httpConnection,
    DownloadEngine* e,
-   const SharedHandle<SocketCore>& s);
+   const std::shared_ptr<SocketCore>& s);
 
   virtual ~AbstractProxyResponseCommand();
 
diff --git a/src/AbstractSingleDiskAdaptor.cc b/src/AbstractSingleDiskAdaptor.cc
index d36ac66c..f3dbcd17 100644
--- a/src/AbstractSingleDiskAdaptor.cc
+++ b/src/AbstractSingleDiskAdaptor.cc
@@ -97,7 +97,7 @@ void AbstractSingleDiskAdaptor::writeCache(const WrDiskCacheEntry* entry)
   for(WrDiskCacheEntry::DataCellSet::const_iterator i = dataSet.begin(),
         eoi = dataSet.end(); i != eoi; ++i) {
     if(start+static_cast<ssize_t>(buflen) < (*i)->goff) {
-      A2_LOG_DEBUG(fmt("Cache flush goff=%"PRId64", len=%lu",
+      A2_LOG_DEBUG(fmt("Cache flush goff=%" PRId64 ", len=%lu",
                        start, static_cast<unsigned long>(buflen)));
       writeData(buf+buffoffset, buflen-buffoffset, start);
       start = (*i)->goff;
@@ -105,7 +105,7 @@ void AbstractSingleDiskAdaptor::writeCache(const WrDiskCacheEntry* entry)
     }
     if(buflen == 0 && ((*i)->goff & 0xfff) == 0 && ((*i)->len & 0xfff) == 0) {
       // Already aligned. Write it without copy.
-      A2_LOG_DEBUG(fmt("Cache flush goff=%"PRId64", len=%lu",
+      A2_LOG_DEBUG(fmt("Cache flush goff=%" PRId64 ", len=%lu",
                        start, static_cast<unsigned long>((*i)->len)));
       writeData((*i)->data + (*i)->offset, (*i)->len, start);
       start += (*i)->len;
@@ -117,7 +117,7 @@ void AbstractSingleDiskAdaptor::writeCache(const WrDiskCacheEntry* entry)
       memcpy(buf+buflen, (*i)->data+(*i)->offset, wlen);
       buflen += wlen;
       if(buflen == sizeof(buf)) {
-        A2_LOG_DEBUG(fmt("Cache flush goff=%"PRId64", len=%lu",
+        A2_LOG_DEBUG(fmt("Cache flush goff=%" PRId64 ", len=%lu",
                          start, static_cast<unsigned long>(buflen)));
         writeData(buf+buffoffset, buflen-buffoffset, start);
         memcpy(buf, (*i)->data + (*i)->offset + wlen, (*i)->len - wlen);
@@ -145,26 +145,26 @@ void AbstractSingleDiskAdaptor::truncate(int64_t length)
   diskWriter_->truncate(length);
 }
 
-SharedHandle<FileAllocationIterator>
+std::shared_ptr<FileAllocationIterator>
 AbstractSingleDiskAdaptor::fileAllocationIterator()
 {
   switch(getFileAllocationMethod()) {
 #ifdef HAVE_SOME_FALLOCATE
   case(DiskAdaptor::FILE_ALLOC_FALLOC): {
-    SharedHandle<FallocFileAllocationIterator> h
+    std::shared_ptr<FallocFileAllocationIterator> h
       (new FallocFileAllocationIterator
        (diskWriter_.get(), size() ,totalLength_));
     return h;
   }
 #endif // HAVE_SOME_FALLOCATE
   case(DiskAdaptor::FILE_ALLOC_TRUNC): {
-    SharedHandle<TruncFileAllocationIterator> h
+    std::shared_ptr<TruncFileAllocationIterator> h
       (new TruncFileAllocationIterator
        (diskWriter_.get(), size(), totalLength_));
     return h;
   }
   default: {
-    SharedHandle<AdaptiveFileAllocationIterator> h
+    std::shared_ptr<AdaptiveFileAllocationIterator> h
       (new AdaptiveFileAllocationIterator
        (diskWriter_.get(), size(), totalLength_));
     return h;
@@ -197,7 +197,7 @@ void AbstractSingleDiskAdaptor::cutTrailingGarbage()
 }
 
 void AbstractSingleDiskAdaptor::setDiskWriter
-(const SharedHandle<DiskWriter>& diskWriter)
+(const std::shared_ptr<DiskWriter>& diskWriter)
 {
   diskWriter_ = diskWriter;
 }
diff --git a/src/AbstractSingleDiskAdaptor.h b/src/AbstractSingleDiskAdaptor.h
index 9a71fb3c..4d27b815 100644
--- a/src/AbstractSingleDiskAdaptor.h
+++ b/src/AbstractSingleDiskAdaptor.h
@@ -44,7 +44,7 @@ class FileAllocationIterator;
 
 class AbstractSingleDiskAdaptor : public DiskAdaptor {
 private:
-  SharedHandle<DiskWriter> diskWriter_;
+  std::shared_ptr<DiskWriter> diskWriter_;
   int64_t totalLength_;
   bool readOnly_;
 public:
@@ -73,7 +73,7 @@ public:
 
   virtual void truncate(int64_t length);
 
-  virtual SharedHandle<FileAllocationIterator> fileAllocationIterator();
+  virtual std::shared_ptr<FileAllocationIterator> fileAllocationIterator();
 
   // Make sure that DiskWriter is set before calling this function.
   virtual void enableReadOnly();
@@ -89,9 +89,9 @@ public:
 
   virtual const std::string& getFilePath() = 0;
 
-  void setDiskWriter(const SharedHandle<DiskWriter>& diskWriter);
+  void setDiskWriter(const std::shared_ptr<DiskWriter>& diskWriter);
 
-  const SharedHandle<DiskWriter>& getDiskWriter() const
+  const std::shared_ptr<DiskWriter>& getDiskWriter() const
   {
     return diskWriter_;
   }
diff --git a/src/ActivePeerConnectionCommand.cc b/src/ActivePeerConnectionCommand.cc
index 4c0dbf65..07ae4d5f 100644
--- a/src/ActivePeerConnectionCommand.cc
+++ b/src/ActivePeerConnectionCommand.cc
@@ -131,7 +131,7 @@ void ActivePeerConnectionCommand::makeNewConnections(int num)
 {
   for(; num && peerStorage_->isPeerAvailable(); --num) {
     cuid_t ncuid = e_->newCUID();
-    SharedHandle<Peer> peer = peerStorage_->checkoutPeer(ncuid);
+    std::shared_ptr<Peer> peer = peerStorage_->checkoutPeer(ncuid);
     // sanity check
     if(!peer) {
       break;
@@ -148,25 +148,25 @@ void ActivePeerConnectionCommand::makeNewConnections(int num)
 }
 
 void ActivePeerConnectionCommand::setBtRuntime
-(const SharedHandle<BtRuntime>& btRuntime)
+(const std::shared_ptr<BtRuntime>& btRuntime)
 {
   btRuntime_ = btRuntime;
 }
 
 void ActivePeerConnectionCommand::setPieceStorage
-(const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
 
 void ActivePeerConnectionCommand::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
 
 void ActivePeerConnectionCommand::setBtAnnounce
-(const SharedHandle<BtAnnounce>& btAnnounce)
+(const std::shared_ptr<BtAnnounce>& btAnnounce)
 {
   btAnnounce_ = btAnnounce;
 }
diff --git a/src/ActivePeerConnectionCommand.h b/src/ActivePeerConnectionCommand.h
index 872eec58..29730907 100644
--- a/src/ActivePeerConnectionCommand.h
+++ b/src/ActivePeerConnectionCommand.h
@@ -36,7 +36,9 @@
 #define D_ACTIVE_PEER_CONNECTION_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "TimerA2.h"
 
 namespace aria2 {
@@ -52,10 +54,10 @@ class BtAnnounce;
 class ActivePeerConnectionCommand : public Command {
 private:
   RequestGroup* requestGroup_;
-  SharedHandle<BtRuntime> btRuntime_;
-  SharedHandle<PieceStorage> pieceStorage_;
-  SharedHandle<PeerStorage> peerStorage_;
-  SharedHandle<BtAnnounce> btAnnounce_;
+  std::shared_ptr<BtRuntime> btRuntime_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
+  std::shared_ptr<BtAnnounce> btAnnounce_;
 
   time_t interval_; // UNIT: sec
   DownloadEngine* e_;
@@ -78,13 +80,13 @@ public:
     numNewConnection_ = numNewConnection;
   }
 
-  void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime);
+  void setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime);
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 
-  void setBtAnnounce(const SharedHandle<BtAnnounce>& btAnnounce);
+  void setBtAnnounce(const std::shared_ptr<BtAnnounce>& btAnnounce);
 };
 
 } // namespace aria2
diff --git a/src/AdaptiveFileAllocationIterator.cc b/src/AdaptiveFileAllocationIterator.cc
index 80874317..f4a116ef 100644
--- a/src/AdaptiveFileAllocationIterator.cc
+++ b/src/AdaptiveFileAllocationIterator.cc
@@ -70,13 +70,13 @@ void AdaptiveFileAllocationIterator::allocateChunk()
         (new FallocFileAllocationIterator(stream_, offset_, totalLength_));
     } catch(RecoverableException& e) {
       A2_LOG_DEBUG("File system does not support fallocate.");
-      SharedHandle<SingleFileAllocationIterator> salloc
+      std::shared_ptr<SingleFileAllocationIterator> salloc
         (new SingleFileAllocationIterator(stream_, offset_, totalLength_));
       salloc->init();
       allocator_ = salloc;
     }
 #else // !HAVE_FALLOCATE
-    SharedHandle<SingleFileAllocationIterator> salloc
+    std::shared_ptr<SingleFileAllocationIterator> salloc
       (new SingleFileAllocationIterator(stream_, offset_, totalLength_));
     salloc->init();
     allocator_ = salloc;
diff --git a/src/AdaptiveFileAllocationIterator.h b/src/AdaptiveFileAllocationIterator.h
index 3dc6c970..6a3fd36c 100644
--- a/src/AdaptiveFileAllocationIterator.h
+++ b/src/AdaptiveFileAllocationIterator.h
@@ -37,6 +37,8 @@
 
 #include "FileAllocationIterator.h"
 
+#include <memory>
+
 namespace aria2 {
 
 class BinaryStream;
@@ -44,7 +46,7 @@ class BinaryStream;
 class AdaptiveFileAllocationIterator:public FileAllocationIterator
 {
 private:
-  SharedHandle<FileAllocationIterator> allocator_;
+  std::shared_ptr<FileAllocationIterator> allocator_;
 
   BinaryStream* stream_;
 
diff --git a/src/AdaptiveURISelector.cc b/src/AdaptiveURISelector.cc
index c063f8c1..cbc84057 100644
--- a/src/AdaptiveURISelector.cc
+++ b/src/AdaptiveURISelector.cc
@@ -66,7 +66,7 @@ namespace aria2 {
  */
 
 AdaptiveURISelector::AdaptiveURISelector
-(const SharedHandle<ServerStatMan>& serverStatMan, RequestGroup* requestGroup)
+(const std::shared_ptr<ServerStatMan>& serverStatMan, RequestGroup* requestGroup)
   : serverStatMan_(serverStatMan),
     requestGroup_(requestGroup)
 {
@@ -242,7 +242,7 @@ void AdaptiveURISelector::adjustLowestSpeedLimit
 }
 
 namespace {
-int getUriMaxSpeed(SharedHandle<ServerStat> ss)
+int getUriMaxSpeed(std::shared_ptr<ServerStat> ss)
 {
   return std::max(ss->getSingleConnectionAvgSpeed(),
                   ss->getMultiConnectionAvgSpeed());
@@ -265,7 +265,7 @@ std::string AdaptiveURISelector::getMaxDownloadSpeedUri
   std::string uri = A2STR::NIL;
   for(std::deque<std::string>::const_iterator i = uris.begin(),
         eoi = uris.end(); i != eoi; ++i) {
-    SharedHandle<ServerStat> ss = getServerStats(*i);
+    std::shared_ptr<ServerStat> ss = getServerStats(*i);
     if(!ss)
       continue;
 
@@ -287,7 +287,7 @@ std::deque<std::string> AdaptiveURISelector::getUrisBySpeed
   std::deque<std::string> bests;
   for(std::deque<std::string>::const_iterator i = uris.begin(),
         eoi = uris.end(); i != eoi; ++i) {
-    SharedHandle<ServerStat> ss = getServerStats(*i);
+    std::shared_ptr<ServerStat> ss = getServerStats(*i);
     if(!ss)
       continue;
     if(ss->getSingleConnectionAvgSpeed() > min ||
@@ -312,7 +312,7 @@ std::string AdaptiveURISelector::getFirstNotTestedUri
 {
   for(std::deque<std::string>::const_iterator i = uris.begin(),
         eoi = uris.end(); i != eoi; ++i) {
-    SharedHandle<ServerStat> ss = getServerStats(*i);
+    std::shared_ptr<ServerStat> ss = getServerStats(*i);
     if(!ss)
       return *i;
   }
@@ -326,7 +326,7 @@ std::string AdaptiveURISelector::getFirstToTestUri
   int power;
   for(std::deque<std::string>::const_iterator i = uris.begin(),
         eoi = uris.end(); i != eoi; ++i) {
-    SharedHandle<ServerStat> ss = getServerStats(*i);
+    std::shared_ptr<ServerStat> ss = getServerStats(*i);
     if(!ss)
       continue;
     counter = ss->getCounter();
@@ -342,7 +342,7 @@ std::string AdaptiveURISelector::getFirstToTestUri
   return A2STR::NIL;
 }
 
-SharedHandle<ServerStat> AdaptiveURISelector::getServerStats
+std::shared_ptr<ServerStat> AdaptiveURISelector::getServerStats
 (const std::string& uri) const
 {
   uri_split_result us;
@@ -351,7 +351,7 @@ SharedHandle<ServerStat> AdaptiveURISelector::getServerStats
     std::string protocol = uri::getFieldString(us, USR_SCHEME, uri.c_str());
     return serverStatMan_->find(host, protocol);
   } else {
-    return SharedHandle<ServerStat>();
+    return std::shared_ptr<ServerStat>();
   }
 }
 
@@ -361,7 +361,7 @@ int AdaptiveURISelector::getNbTestedServers
   int counter = 0;
   for(std::deque<std::string>::const_iterator i = uris.begin(),
         eoi = uris.end(); i != eoi; ++i) {
-    SharedHandle<ServerStat> ss = getServerStats(*i);
+    std::shared_ptr<ServerStat> ss = getServerStats(*i);
     if(!ss)
       ++counter;
   }
diff --git a/src/AdaptiveURISelector.h b/src/AdaptiveURISelector.h
index df462e07..d4dfdab2 100644
--- a/src/AdaptiveURISelector.h
+++ b/src/AdaptiveURISelector.h
@@ -36,7 +36,8 @@
 #ifndef D_ADAPTIVE_URI_SELECTOR_H
 #define D_ADAPTIVE_URI_SELECTOR_H
 #include "URISelector.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -46,7 +47,7 @@ class ServerStat;
 
 class AdaptiveURISelector:public URISelector {
 private:
-  SharedHandle<ServerStatMan> serverStatMan_;
+  std::shared_ptr<ServerStatMan> serverStatMan_;
   // No need to delete requestGroup_
   RequestGroup* requestGroup_;
   int nbServerToEvaluate_;
@@ -66,11 +67,11 @@ private:
   std::string selectRandomUri(const std::deque<std::string>& uris) const;
   std::string getFirstNotTestedUri(const std::deque<std::string>& uris) const;
   std::string getFirstToTestUri(const std::deque<std::string>& uris) const;
-  SharedHandle<ServerStat> getServerStats(const std::string& uri) const;
+  std::shared_ptr<ServerStat> getServerStats(const std::string& uri) const;
   int getNbTestedServers(const std::deque<std::string>& uris) const;
   std::string getBestMirror(const std::deque<std::string>& uris) const;
 public:
-  AdaptiveURISelector(const SharedHandle<ServerStatMan>& serverStatMan,
+  AdaptiveURISelector(const std::shared_ptr<ServerStatMan>& serverStatMan,
                       RequestGroup* requestGroup);
 
   virtual ~AdaptiveURISelector();
diff --git a/src/AnnounceList.cc b/src/AnnounceList.cc
index e41b278e..f21634aa 100644
--- a/src/AnnounceList.cc
+++ b/src/AnnounceList.cc
@@ -51,7 +51,7 @@ AnnounceList::AnnounceList
 }
 
 AnnounceList::AnnounceList
-(const std::deque<SharedHandle<AnnounceTier> >& announceTiers):
+(const std::deque<std::shared_ptr<AnnounceTier> >& announceTiers):
   tiers_(announceTiers), currentTrackerInitialized_(false)  {
   resetIterator();
 }
@@ -67,7 +67,7 @@ void AnnounceList::reconfigure
       continue;
     }
     std::deque<std::string> urls((*itr).begin(), (*itr).end());
-    SharedHandle<AnnounceTier> tier(new AnnounceTier(urls));
+    std::shared_ptr<AnnounceTier> tier(new AnnounceTier(urls));
     tiers_.push_back(tier);
   }
   resetIterator();
@@ -76,7 +76,7 @@ void AnnounceList::reconfigure
 void AnnounceList::reconfigure(const std::string& url) {
   std::deque<std::string> urls;
   urls.push_back(url);
-  SharedHandle<AnnounceTier> tier(new AnnounceTier(urls));
+  std::shared_ptr<AnnounceTier> tier(new AnnounceTier(urls));
   tiers_.push_back(tier);
   resetIterator();
 }
@@ -161,7 +161,7 @@ const char* AnnounceList::getEventString() const {
 namespace {
 class FindStoppedAllowedTier {
 public:
-  bool operator()(const SharedHandle<AnnounceTier>& tier) const {
+  bool operator()(const std::shared_ptr<AnnounceTier>& tier) const {
     switch(tier->event) {
     case AnnounceTier::DOWNLOADING:
     case AnnounceTier::STOPPED:
@@ -178,7 +178,7 @@ public:
 namespace {
 class FindCompletedAllowedTier {
 public:
-  bool operator()(const SharedHandle<AnnounceTier>& tier) const {
+  bool operator()(const std::shared_ptr<AnnounceTier>& tier) const {
     switch(tier->event) {
     case AnnounceTier::DOWNLOADING:
     case AnnounceTier::COMPLETED:
@@ -199,7 +199,7 @@ size_t AnnounceList::countCompletedAllowedTier() const {
 }
 
 void AnnounceList::setCurrentTier
-(const std::deque<SharedHandle<AnnounceTier> >::iterator& itr) {
+(const std::deque<std::shared_ptr<AnnounceTier> >::iterator& itr) {
   if(itr != tiers_.end()) {
     currentTier_ = itr;
     currentTracker_ = (*currentTier_)->urls.begin();
@@ -207,7 +207,7 @@ void AnnounceList::setCurrentTier
 }
 
 void AnnounceList::moveToStoppedAllowedTier() {
-  std::deque<SharedHandle<AnnounceTier> >::iterator itr =
+  std::deque<std::shared_ptr<AnnounceTier> >::iterator itr =
     find_wrap_if(tiers_.begin(), tiers_.end(),
                  currentTier_,
                  FindStoppedAllowedTier());
@@ -215,7 +215,7 @@ void AnnounceList::moveToStoppedAllowedTier() {
 }
 
 void AnnounceList::moveToCompletedAllowedTier() {
-  std::deque<SharedHandle<AnnounceTier> >::iterator itr =
+  std::deque<std::shared_ptr<AnnounceTier> >::iterator itr =
     find_wrap_if(tiers_.begin(), tiers_.end(),
                  currentTier_,
                  FindCompletedAllowedTier());
@@ -223,7 +223,7 @@ void AnnounceList::moveToCompletedAllowedTier() {
 }
 
 void AnnounceList::shuffle() {
-  for(std::deque<SharedHandle<AnnounceTier> >::const_iterator itr =
+  for(std::deque<std::shared_ptr<AnnounceTier> >::const_iterator itr =
         tiers_.begin(), eoi = tiers_.end(); itr != eoi; ++itr) {
     std::deque<std::string>& urls = (*itr)->urls;
     std::random_shuffle(urls.begin(), urls.end(),
diff --git a/src/AnnounceList.h b/src/AnnounceList.h
index 61e26c93..fc07c8d8 100644
--- a/src/AnnounceList.h
+++ b/src/AnnounceList.h
@@ -36,7 +36,9 @@
 #define D_ANNOUNCE_LIST_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "AnnounceTier.h"
 #include "ValueBase.h"
 
@@ -45,18 +47,18 @@ namespace aria2 {
 class AnnounceList {
 public:
 private:
-  std::deque<SharedHandle<AnnounceTier> > tiers_;
-  std::deque<SharedHandle<AnnounceTier> >::iterator currentTier_;
+  std::deque<std::shared_ptr<AnnounceTier> > tiers_;
+  std::deque<std::shared_ptr<AnnounceTier> >::iterator currentTier_;
   std::deque<std::string>::iterator currentTracker_;
   bool currentTrackerInitialized_;
 
   void resetIterator();
   void setCurrentTier
-  (const std::deque<SharedHandle<AnnounceTier> >::iterator& itr);
+  (const std::deque<std::shared_ptr<AnnounceTier> >::iterator& itr);
 public:
   AnnounceList();
   AnnounceList(const std::vector<std::vector<std::string> >& announceList);
-  AnnounceList(const std::deque<SharedHandle<AnnounceTier> >& tiers);
+  AnnounceList(const std::deque<std::shared_ptr<AnnounceTier> >& tiers);
   ~AnnounceList();
 
   // Don't allow copying
diff --git a/src/AnnounceTier.h b/src/AnnounceTier.h
index 77de3759..44fa1abf 100644
--- a/src/AnnounceTier.h
+++ b/src/AnnounceTier.h
@@ -40,8 +40,6 @@
 #include <string>
 #include <deque>
 
-#include "SharedHandle.h"
-
 namespace aria2 {
 
 class AnnounceTier {
diff --git a/src/AnonDiskWriterFactory.h b/src/AnonDiskWriterFactory.h
index f92556d1..60146827 100644
--- a/src/AnonDiskWriterFactory.h
+++ b/src/AnonDiskWriterFactory.h
@@ -47,9 +47,9 @@ public:
   AnonDiskWriterFactory() {}
   virtual ~AnonDiskWriterFactory() {}
 
-  virtual SharedHandle<DiskWriter> newDiskWriter(const std::string& filename)
+  virtual std::shared_ptr<DiskWriter> newDiskWriter(const std::string& filename)
   {
-    return SharedHandle<DiskWriter>(new DiskWriterType());
+    return std::shared_ptr<DiskWriter>(new DiskWriterType());
   }
 };
 
diff --git a/src/AppleMessageDigestImpl.cc b/src/AppleMessageDigestImpl.cc
index 7d8eafb1..4550d1eb 100644
--- a/src/AppleMessageDigestImpl.cc
+++ b/src/AppleMessageDigestImpl.cc
@@ -108,33 +108,33 @@ typedef MessageDigestBase<CC_SHA512_DIGEST_LENGTH,
                           CC_SHA512_Final>
 MessageDigestSHA512;
 
-SharedHandle<MessageDigestImpl> MessageDigestImpl::sha1()
+std::shared_ptr<MessageDigestImpl> MessageDigestImpl::sha1()
 {
-  return SharedHandle<MessageDigestImpl>(new MessageDigestSHA1());
+  return std::shared_ptr<MessageDigestImpl>(new MessageDigestSHA1());
 }
 
-SharedHandle<MessageDigestImpl> MessageDigestImpl::create
+std::shared_ptr<MessageDigestImpl> MessageDigestImpl::create
 (const std::string& hashType)
 {
   if (hashType == "sha-1") {
-    return SharedHandle<MessageDigestImpl>(new MessageDigestSHA1());
+    return std::shared_ptr<MessageDigestImpl>(new MessageDigestSHA1());
   }
   if (hashType == "sha-224") {
-    return SharedHandle<MessageDigestImpl>(new MessageDigestSHA224());
+    return std::shared_ptr<MessageDigestImpl>(new MessageDigestSHA224());
   }
   if (hashType == "sha-256") {
-    return SharedHandle<MessageDigestImpl>(new MessageDigestSHA256());
+    return std::shared_ptr<MessageDigestImpl>(new MessageDigestSHA256());
   }
   if (hashType == "sha-384") {
-    return SharedHandle<MessageDigestImpl>(new MessageDigestSHA384());
+    return std::shared_ptr<MessageDigestImpl>(new MessageDigestSHA384());
   }
   if (hashType == "sha-512") {
-    return SharedHandle<MessageDigestImpl>(new MessageDigestSHA512());
+    return std::shared_ptr<MessageDigestImpl>(new MessageDigestSHA512());
   }
   if (hashType == "md5") {
-    return SharedHandle<MessageDigestImpl>(new MessageDigestMD5());
+    return std::shared_ptr<MessageDigestImpl>(new MessageDigestMD5());
   }
-  return SharedHandle<MessageDigestImpl>();
+  return std::shared_ptr<MessageDigestImpl>();
 }
 
 bool MessageDigestImpl::supports(const std::string& hashType)
@@ -144,7 +144,7 @@ bool MessageDigestImpl::supports(const std::string& hashType)
 
 size_t MessageDigestImpl::getDigestLength(const std::string& hashType)
 {
-  SharedHandle<MessageDigestImpl> impl = create(hashType);
+  std::shared_ptr<MessageDigestImpl> impl = create(hashType);
   if (!impl) {
     return 0;
   }
diff --git a/src/AppleMessageDigestImpl.h b/src/AppleMessageDigestImpl.h
index 91992603..de9aef83 100644
--- a/src/AppleMessageDigestImpl.h
+++ b/src/AppleMessageDigestImpl.h
@@ -38,16 +38,15 @@
 #include "common.h"
 
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
 class MessageDigestImpl {
 public:
   virtual ~MessageDigestImpl() {}
-  static SharedHandle<MessageDigestImpl> sha1();
-  static SharedHandle<MessageDigestImpl> create(const std::string& hashType);
+  static std::shared_ptr<MessageDigestImpl> sha1();
+  static std::shared_ptr<MessageDigestImpl> create(const std::string& hashType);
 
   static bool supports(const std::string& hashType);
   static size_t getDigestLength(const std::string& hashType);
diff --git a/src/AsyncNameResolver.h b/src/AsyncNameResolver.h
index 905fe0ec..fac6df5e 100644
--- a/src/AsyncNameResolver.h
+++ b/src/AsyncNameResolver.h
@@ -42,7 +42,6 @@
 
 #include <ares.h>
 
-#include "SharedHandle.h"
 #include "a2netcompat.h"
 
 namespace aria2 {
diff --git a/src/AsyncNameResolverMan.cc b/src/AsyncNameResolverMan.cc
index 89efc78f..c6ad8da6 100644
--- a/src/AsyncNameResolverMan.cc
+++ b/src/AsyncNameResolverMan.cc
@@ -33,6 +33,9 @@
  */
 /* copyright --> */
 #include "AsyncNameResolverMan.h"
+
+#include <cassert>
+
 #include "AsyncNameResolver.h"
 #include "DownloadEngine.h"
 #include "Command.h"
diff --git a/src/AsyncNameResolverMan.h b/src/AsyncNameResolverMan.h
index ef1dd599..6f84434e 100644
--- a/src/AsyncNameResolverMan.h
+++ b/src/AsyncNameResolverMan.h
@@ -39,8 +39,7 @@
 
 #include <vector>
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -97,7 +96,7 @@ private:
   void disableNameResolverCheck(size_t index, DownloadEngine* e,
                                 Command* command);
 
-  SharedHandle<AsyncNameResolver> asyncNameResolver_[2];
+  std::shared_ptr<AsyncNameResolver> asyncNameResolver_[2];
   size_t numResolver_;
   int resolverCheck_;
   bool ipv4_;
diff --git a/src/AuthConfig.cc b/src/AuthConfig.cc
index 78370749..ed9c465f 100644
--- a/src/AuthConfig.cc
+++ b/src/AuthConfig.cc
@@ -58,7 +58,7 @@ std::string AuthConfig::getAuthText() const
 }
 
 std::ostream& operator<<(std::ostream& o,
-                         const SharedHandle<AuthConfig>& authConfig)
+                         const std::shared_ptr<AuthConfig>& authConfig)
 {
   o << authConfig->getAuthText();
   return o;
diff --git a/src/AuthConfig.h b/src/AuthConfig.h
index 83d728eb..cae54a40 100644
--- a/src/AuthConfig.h
+++ b/src/AuthConfig.h
@@ -39,8 +39,7 @@
 
 #include <string>
 #include <iosfwd>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -72,7 +71,7 @@ public:
 };
 
 std::ostream& operator<<(std::ostream& o,
-                         const SharedHandle<AuthConfig>& authConfig);
+                         const std::shared_ptr<AuthConfig>& authConfig);
 
 } // namespace aria2
 
diff --git a/src/AuthConfigFactory.cc b/src/AuthConfigFactory.cc
index 525b984a..802ad367 100644
--- a/src/AuthConfigFactory.cc
+++ b/src/AuthConfigFactory.cc
@@ -56,15 +56,15 @@ AuthConfigFactory::AuthConfigFactory() {}
 
 AuthConfigFactory::~AuthConfigFactory() {}
 
-SharedHandle<AuthConfig>
+std::shared_ptr<AuthConfig>
 AuthConfigFactory::createAuthConfig
-(const SharedHandle<Request>& request, const Option* op)
+(const std::shared_ptr<Request>& request, const Option* op)
 {
   if(request->getProtocol() == "http" || request->getProtocol() == "https") {
 
     if(op->getAsBool(PREF_HTTP_AUTH_CHALLENGE)) {
       if(!request->getUsername().empty()) {
-        SharedHandle<BasicCred> bc(new BasicCred(request->getUsername(),
+        std::shared_ptr<BasicCred> bc(new BasicCred(request->getUsername(),
                                                  request->getPassword(),
                                                  request->getHost(),
                                                  request->getPort(),
@@ -76,7 +76,7 @@ AuthConfigFactory::createAuthConfig
         findBasicCred(request->getHost(), request->getPort(),
                       request->getDir());
       if(i == basicCreds_.end()) {
-        return SharedHandle<AuthConfig>();
+        return std::shared_ptr<AuthConfig>();
       } else {
         return createAuthConfig((*i)->user_, (*i)->password_);
       }
@@ -99,7 +99,7 @@ AuthConfigFactory::createAuthConfig
           NetrcAuthResolver authResolver;
           authResolver.setNetrc(netrc_);
 
-          SharedHandle<AuthConfig> ac =
+          std::shared_ptr<AuthConfig> ac =
             authResolver.resolveAuthConfig(request->getHost());
           if(ac && ac->getUser() == request->getUsername()) {
             return ac;
@@ -115,21 +115,21 @@ AuthConfigFactory::createAuthConfig
         createFtpAuthResolver(op)->resolveAuthConfig(request->getHost());
     }
   } else {
-    return SharedHandle<AuthConfig>();
+    return std::shared_ptr<AuthConfig>();
   }
 }
 
-SharedHandle<AuthConfig>
+std::shared_ptr<AuthConfig>
 AuthConfigFactory::createAuthConfig(const std::string& user, const std::string& password) const
 {
-  SharedHandle<AuthConfig> ac;
+  std::shared_ptr<AuthConfig> ac;
   if(!user.empty()) {
     ac.reset(new AuthConfig(user, password));
   }
   return ac;
 }
 
-SharedHandle<AuthResolver> AuthConfigFactory::createHttpAuthResolver
+std::shared_ptr<AuthResolver> AuthConfigFactory::createHttpAuthResolver
 (const Option* op) const
 {
   AbstractAuthResolver* resolver;
@@ -143,10 +143,10 @@ SharedHandle<AuthResolver> AuthConfigFactory::createHttpAuthResolver
   }
   resolver->setUserDefinedAuthConfig
     (createAuthConfig(op->get(PREF_HTTP_USER), op->get(PREF_HTTP_PASSWD)));
-  return SharedHandle<AuthResolver>(resolver);
+  return std::shared_ptr<AuthResolver>(resolver);
 }
 
-SharedHandle<AuthResolver> AuthConfigFactory::createFtpAuthResolver
+std::shared_ptr<AuthResolver> AuthConfigFactory::createFtpAuthResolver
 (const Option* op) const
 {
   AbstractAuthResolver* resolver;
@@ -159,19 +159,19 @@ SharedHandle<AuthResolver> AuthConfigFactory::createFtpAuthResolver
   }
   resolver->setUserDefinedAuthConfig
     (createAuthConfig(op->get(PREF_FTP_USER), op->get(PREF_FTP_PASSWD)));
-  SharedHandle<AuthConfig> defaultAuthConfig
+  std::shared_ptr<AuthConfig> defaultAuthConfig
     (new AuthConfig(AUTH_DEFAULT_USER, AUTH_DEFAULT_PASSWD));
   resolver->setDefaultAuthConfig(defaultAuthConfig);
-  return SharedHandle<AuthResolver>(resolver);
+  return std::shared_ptr<AuthResolver>(resolver);
 }
 
-void AuthConfigFactory::setNetrc(const SharedHandle<Netrc>& netrc)
+void AuthConfigFactory::setNetrc(const std::shared_ptr<Netrc>& netrc)
 {
   netrc_ = netrc;
 }
 
 void AuthConfigFactory::updateBasicCred
-(const SharedHandle<BasicCred>& basicCred)
+(const std::shared_ptr<BasicCred>& basicCred)
 {
   BasicCredSet::iterator i = basicCreds_.lower_bound(basicCred);
   if(i != basicCreds_.end() && *(*i) == *basicCred) {
@@ -189,12 +189,12 @@ bool AuthConfigFactory::activateBasicCred
 {
   BasicCredSet::iterator i = findBasicCred(host, port, path);
   if(i == basicCreds_.end()) {
-    SharedHandle<AuthConfig> authConfig =
+    std::shared_ptr<AuthConfig> authConfig =
       createHttpAuthResolver(op)->resolveAuthConfig(host);
     if(!authConfig) {
       return false;
     } else {
-      SharedHandle<BasicCred> bc
+      std::shared_ptr<BasicCred> bc
         (new BasicCred(authConfig->getUser(), authConfig->getPassword(),
                        host, port, path, true));
       basicCreds_.insert(bc);
@@ -246,7 +246,7 @@ AuthConfigFactory::findBasicCred
  uint16_t port,
  const std::string& path)
 {
-  SharedHandle<BasicCred> bc(new BasicCred("", "", host, port, path));
+  std::shared_ptr<BasicCred> bc(new BasicCred("", "", host, port, path));
   BasicCredSet::iterator i = basicCreds_.lower_bound(bc);
   for(; i != basicCreds_.end() && (*i)->host_ == host && (*i)->port_ == port;
       ++i) {
diff --git a/src/AuthConfigFactory.h b/src/AuthConfigFactory.h
index 6b520e2d..e863db6d 100644
--- a/src/AuthConfigFactory.h
+++ b/src/AuthConfigFactory.h
@@ -39,8 +39,8 @@
 
 #include <string>
 #include <set>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "SingletonHolder.h"
 #include "a2functional.h"
 
@@ -54,14 +54,14 @@ class AuthResolver;
 
 class AuthConfigFactory {
 private:
-  SharedHandle<Netrc> netrc_;
+  std::shared_ptr<Netrc> netrc_;
 
-  SharedHandle<AuthConfig> createAuthConfig(const std::string& user,
+  std::shared_ptr<AuthConfig> createAuthConfig(const std::string& user,
                                             const std::string& password) const;
 
-  SharedHandle<AuthResolver> createHttpAuthResolver(const Option* op) const;
+  std::shared_ptr<AuthResolver> createHttpAuthResolver(const Option* op) const;
 
-  SharedHandle<AuthResolver> createFtpAuthResolver(const Option* op) const;
+  std::shared_ptr<AuthResolver> createFtpAuthResolver(const Option* op) const;
 public:
   class BasicCred {
   public:
@@ -85,8 +85,8 @@ public:
     bool operator<(const BasicCred& cred) const;
   };
 
-  typedef std::set<SharedHandle<BasicCred>,
-                   DerefLess<SharedHandle<BasicCred> > > BasicCredSet;
+  typedef std::set<std::shared_ptr<BasicCred>,
+                   DerefLess<std::shared_ptr<BasicCred> > > BasicCredSet;
 private:
   BasicCredSet basicCreds_;
 public:
@@ -98,10 +98,10 @@ public:
   // are used in this method: PREF_HTTP_USER, PREF_HTTP_PASSWD,
   // PREF_FTP_USER, PREF_FTP_PASSWD, PREF_NO_NETRC and
   // PREF_HTTP_AUTH_CHALLENGE.
-  SharedHandle<AuthConfig> createAuthConfig
-  (const SharedHandle<Request>& request, const Option* op);
+  std::shared_ptr<AuthConfig> createAuthConfig
+  (const std::shared_ptr<Request>& request, const Option* op);
 
-  void setNetrc(const SharedHandle<Netrc>& netrc);
+  void setNetrc(const std::shared_ptr<Netrc>& netrc);
 
   // Find a BasicCred using findBasicCred() and activate it then
   // return true.  If matching BasicCred is not found, AuthConfig
@@ -127,7 +127,7 @@ public:
   // If the same BasicCred is already added, then it is replaced with
   // given basicCred. Otherwise, insert given basicCred to
   // basicCreds_.
-  void updateBasicCred(const SharedHandle<BasicCred>& basicCred);
+  void updateBasicCred(const std::shared_ptr<BasicCred>& basicCred);
 };
 
 } // namespace aria2
diff --git a/src/AuthResolver.h b/src/AuthResolver.h
index ab2cccf7..e3b83449 100644
--- a/src/AuthResolver.h
+++ b/src/AuthResolver.h
@@ -38,8 +38,7 @@
 #include "common.h"
 
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -49,7 +48,7 @@ class AuthResolver {
 public:
   virtual ~AuthResolver() {}
 
-  virtual SharedHandle<AuthConfig> resolveAuthConfig(const std::string& hostname) = 0;
+  virtual std::shared_ptr<AuthConfig> resolveAuthConfig(const std::string& hostname) = 0;
 };
 
 } // namespace aria2
diff --git a/src/BackupIPv4ConnectCommand.cc b/src/BackupIPv4ConnectCommand.cc
index 9ca2081b..5c61434b 100644
--- a/src/BackupIPv4ConnectCommand.cc
+++ b/src/BackupIPv4ConnectCommand.cc
@@ -51,7 +51,7 @@ BackupConnectInfo::BackupConnectInfo()
 
 BackupIPv4ConnectCommand::BackupIPv4ConnectCommand
 (cuid_t cuid, const std::string& ipaddr, uint16_t port,
- const SharedHandle<BackupConnectInfo>& info, Command* mainCommand,
+ const std::shared_ptr<BackupConnectInfo>& info, Command* mainCommand,
  RequestGroup* requestGroup, DownloadEngine* e)
 : Command(cuid),
   ipaddr_(ipaddr),
@@ -83,14 +83,15 @@ bool BackupIPv4ConnectCommand::execute()
   if(requestGroup_->downloadFinished() || requestGroup_->isHaltRequested()) {
     retval = true;
   } else if(info_->cancel) {
-    A2_LOG_INFO(fmt("CUID#%"PRId64" - Backup connection canceled", getCuid()));
+    A2_LOG_INFO(fmt("CUID#%" PRId64 " - Backup connection canceled",
+                    getCuid()));
     retval = true;
   } else if(socket_) {
     if(writeEventEnabled()) {
       try {
         std::string error = socket_->getSocketError();
         if(error.empty()) {
-          A2_LOG_INFO(fmt("CUID#%"PRId64" - Backup connection to %s "
+          A2_LOG_INFO(fmt("CUID#%" PRId64 " - Backup connection to %s "
                           "established", getCuid(), ipaddr_.c_str()));
           info_->ipaddr = ipaddr_;
           e_->deleteSocketForWriteCheck(socket_, this);
@@ -99,12 +100,12 @@ bool BackupIPv4ConnectCommand::execute()
           e_->setNoWait(true);
           retval = true;
         } else {
-          A2_LOG_INFO(fmt("CUID#%"PRId64" - Backup connection failed: %s",
+          A2_LOG_INFO(fmt("CUID#%" PRId64 " - Backup connection failed: %s",
                           getCuid(), error.c_str()));
           retval = true;
         }
       } catch(RecoverableException& e) {
-        A2_LOG_INFO_EX(fmt("CUID#%"PRId64" - Backup connection failed",
+        A2_LOG_INFO_EX(fmt("CUID#%" PRId64 " - Backup connection failed",
                            getCuid()), e);
         retval = true;
       }
@@ -120,14 +121,14 @@ bool BackupIPv4ConnectCommand::execute()
         e_->addSocketForWriteCheck(socket_, this);
         timeoutCheck_ = global::wallclock();
       } catch(RecoverableException& e) {
-        A2_LOG_INFO_EX(fmt("CUID#%"PRId64" - Backup connection failed",
+        A2_LOG_INFO_EX(fmt("CUID#%" PRId64 " - Backup connection failed",
                            getCuid()), e);
         socket_.reset();
         retval = true;
       }
     }
   } else if(timeoutCheck_.difference(global::wallclock()) >= timeout_) {
-    A2_LOG_INFO(fmt("CUID#%"PRId64" - Backup connection command timeout",
+    A2_LOG_INFO(fmt("CUID#%" PRId64 " - Backup connection command timeout",
                     getCuid()));
     retval = true;
   }
diff --git a/src/BackupIPv4ConnectCommand.h b/src/BackupIPv4ConnectCommand.h
index de207bc1..b6354e7a 100644
--- a/src/BackupIPv4ConnectCommand.h
+++ b/src/BackupIPv4ConnectCommand.h
@@ -38,8 +38,8 @@
 #include "Command.h"
 
 #include <string>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimerA2.h"
 
 namespace aria2 {
@@ -55,7 +55,7 @@ class SocketCore;
 // member becomes true.
 struct BackupConnectInfo {
   std::string ipaddr;
-  SharedHandle<SocketCore> socket;
+  std::shared_ptr<SocketCore> socket;
   bool cancel;
   BackupConnectInfo();
 };
@@ -66,7 +66,7 @@ class BackupIPv4ConnectCommand : public Command {
 public:
   BackupIPv4ConnectCommand(cuid_t cuid,
                            const std::string& ipaddr, uint16_t port,
-                           const SharedHandle<BackupConnectInfo>& info,
+                           const std::shared_ptr<BackupConnectInfo>& info,
                            Command* mainCommand,
                            RequestGroup* requestGroup, DownloadEngine* e);
   ~BackupIPv4ConnectCommand();
@@ -74,8 +74,8 @@ public:
 private:
   std::string ipaddr_;
   uint16_t port_;
-  SharedHandle<SocketCore> socket_;
-  SharedHandle<BackupConnectInfo> info_;
+  std::shared_ptr<SocketCore> socket_;
+  std::shared_ptr<BackupConnectInfo> info_;
   Command* mainCommand_;
   RequestGroup* requestGroup_;
   DownloadEngine* e_;
diff --git a/src/BencodeParser.cc b/src/BencodeParser.cc
index 9b4861f7..b04f288f 100644
--- a/src/BencodeParser.cc
+++ b/src/BencodeParser.cc
@@ -33,6 +33,9 @@
  */
 /* copyright --> */
 #include "BencodeParser.h"
+
+#include <cassert>
+
 #include "StructParserStateMachine.h"
 #include "util.h"
 
diff --git a/src/BitfieldMan.h b/src/BitfieldMan.h
index fa856c08..fa0ac09f 100644
--- a/src/BitfieldMan.h
+++ b/src/BitfieldMan.h
@@ -39,8 +39,6 @@
 
 #include <vector>
 
-#include "SharedHandle.h"
-
 namespace aria2 {
 
 class BitfieldMan {
diff --git a/src/BtAbortOutstandingRequestEvent.cc b/src/BtAbortOutstandingRequestEvent.cc
index e015a3f3..6afc6f60 100644
--- a/src/BtAbortOutstandingRequestEvent.cc
+++ b/src/BtAbortOutstandingRequestEvent.cc
@@ -38,7 +38,7 @@
 namespace aria2 {
 
 BtAbortOutstandingRequestEvent::BtAbortOutstandingRequestEvent
-(const SharedHandle<Piece>& piece)
+(const std::shared_ptr<Piece>& piece)
   : piece_(piece)
 {}
 
diff --git a/src/BtAbortOutstandingRequestEvent.h b/src/BtAbortOutstandingRequestEvent.h
index cd58d50e..b93cd0eb 100644
--- a/src/BtAbortOutstandingRequestEvent.h
+++ b/src/BtAbortOutstandingRequestEvent.h
@@ -36,7 +36,8 @@
 #define D_BT_ABORT_OUTSTANDING_REQUEST_EVENT_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -44,12 +45,12 @@ class Piece;
 
 class BtAbortOutstandingRequestEvent {
 private:
-  SharedHandle<Piece> piece_;
+  std::shared_ptr<Piece> piece_;
 public:
-  BtAbortOutstandingRequestEvent(const SharedHandle<Piece>& piece);
+  BtAbortOutstandingRequestEvent(const std::shared_ptr<Piece>& piece);
   ~BtAbortOutstandingRequestEvent();
 
-  const SharedHandle<Piece>& getPiece() const { return piece_; }
+  const std::shared_ptr<Piece>& getPiece() const { return piece_; }
 };
 
 } // namespace aria2
diff --git a/src/BtAllowedFastMessage.cc b/src/BtAllowedFastMessage.cc
index e0fa3b9b..9400f5b5 100644
--- a/src/BtAllowedFastMessage.cc
+++ b/src/BtAllowedFastMessage.cc
@@ -65,7 +65,7 @@ void BtAllowedFastMessage::doReceivedAction() {
 
 namespace {
 struct ThisProgressUpdate : public ProgressUpdate {
-  ThisProgressUpdate(const SharedHandle<Peer>& peer, size_t index)
+  ThisProgressUpdate(const std::shared_ptr<Peer>& peer, size_t index)
     : peer(peer), index(index) {}
   virtual void update(size_t length, bool complete)
   {
@@ -73,7 +73,7 @@ struct ThisProgressUpdate : public ProgressUpdate {
       peer->addAmAllowedIndex(index);
     }
   }
-  SharedHandle<Peer> peer;
+  std::shared_ptr<Peer> peer;
   size_t index;
 };
 } // namespace
diff --git a/src/BtAnnounce.h b/src/BtAnnounce.h
index a660b9ba..de1a0524 100644
--- a/src/BtAnnounce.h
+++ b/src/BtAnnounce.h
@@ -38,9 +38,9 @@
 #include "common.h"
 
 #include <string>
+#include <memory>
 
 #include "a2time.h"
-#include "SharedHandle.h"
 
 namespace aria2 {
 
@@ -68,7 +68,7 @@ public:
    */
   virtual std::string getAnnounceUrl() = 0;
 
-  virtual SharedHandle<UDPTrackerRequest>
+  virtual std::shared_ptr<UDPTrackerRequest>
   createUDPTrackerRequest(const std::string& remoteAddr, uint16_t remotePort,
                           uint16_t localPort) = 0;
 
@@ -104,7 +104,7 @@ public:
                                        size_t trackerResponseLength) = 0;
 
   virtual void processUDPTrackerResponse
-  (const SharedHandle<UDPTrackerRequest>& req) = 0;
+  (const std::shared_ptr<UDPTrackerRequest>& req) = 0;
 
   /**
    * Returns true if no more announce is needed.
diff --git a/src/BtCheckIntegrityEntry.cc b/src/BtCheckIntegrityEntry.cc
index f7428bff..8121d869 100644
--- a/src/BtCheckIntegrityEntry.cc
+++ b/src/BtCheckIntegrityEntry.cc
@@ -51,19 +51,19 @@ BtCheckIntegrityEntry::~BtCheckIntegrityEntry() {}
 void BtCheckIntegrityEntry::onDownloadIncomplete
 (std::vector<Command*>& commands, DownloadEngine* e)
 {
-  const SharedHandle<PieceStorage>& ps = getRequestGroup()->getPieceStorage();
+  const std::shared_ptr<PieceStorage>& ps = getRequestGroup()->getPieceStorage();
   ps->onDownloadIncomplete();
   if(getRequestGroup()->getOption()->getAsBool(PREF_HASH_CHECK_ONLY)) {
     return;
   }
-  const SharedHandle<DiskAdaptor>& diskAdaptor = ps->getDiskAdaptor();
+  const std::shared_ptr<DiskAdaptor>& diskAdaptor = ps->getDiskAdaptor();
   if(diskAdaptor->isReadOnlyEnabled()) {
     // Now reopen DiskAdaptor with read only disabled.
     diskAdaptor->closeFile();
     diskAdaptor->disableReadOnly();
     diskAdaptor->openFile();
   }
-  SharedHandle<BtFileAllocationEntry> entry
+  std::shared_ptr<BtFileAllocationEntry> entry
     (new BtFileAllocationEntry(getRequestGroup()));
   proceedFileAllocation(commands, entry, e);
 }
@@ -77,7 +77,7 @@ void BtCheckIntegrityEntry::onDownloadFinished
   // behavior.
   if(!getRequestGroup()->getOption()->getAsBool(PREF_HASH_CHECK_ONLY) &&
      getRequestGroup()->getOption()->getAsBool(PREF_BT_HASH_CHECK_SEED)) {
-    SharedHandle<BtFileAllocationEntry> entry
+    std::shared_ptr<BtFileAllocationEntry> entry
       (new BtFileAllocationEntry(getRequestGroup()));
     proceedFileAllocation(commands, entry, e);
   }
diff --git a/src/BtChokeMessage.cc b/src/BtChokeMessage.cc
index ac82bd0a..e8ac9bdf 100644
--- a/src/BtChokeMessage.cc
+++ b/src/BtChokeMessage.cc
@@ -67,7 +67,7 @@ bool BtChokeMessage::sendPredicate() const
 
 namespace {
 struct ThisProgressUpdate : public ProgressUpdate {
-  ThisProgressUpdate(const SharedHandle<Peer>& peer,
+  ThisProgressUpdate(const std::shared_ptr<Peer>& peer,
                      BtMessageDispatcher* disp)
     : peer(peer), disp(disp) {}
   virtual void update(size_t length, bool complete)
@@ -77,7 +77,7 @@ struct ThisProgressUpdate : public ProgressUpdate {
       disp->doChokingAction();
     }
   }
-  SharedHandle<Peer> peer;
+  std::shared_ptr<Peer> peer;
   BtMessageDispatcher* disp;
 };
 } // namespace
diff --git a/src/BtDependency.cc b/src/BtDependency.cc
index 8862e9c3..9c9976bf 100644
--- a/src/BtDependency.cc
+++ b/src/BtDependency.cc
@@ -54,7 +54,7 @@ namespace aria2 {
 
 BtDependency::BtDependency
 (RequestGroup* dependant,
- const SharedHandle<RequestGroup>& dependee)
+ const std::shared_ptr<RequestGroup>& dependee)
   : dependant_(dependant),
     dependee_(dependee)
 {}
@@ -62,8 +62,8 @@ BtDependency::BtDependency
 BtDependency::~BtDependency() {}
 
 namespace {
-void copyValues(const SharedHandle<FileEntry>& d,
-                const SharedHandle<FileEntry>& s)
+void copyValues(const std::shared_ptr<FileEntry>& d,
+                const std::shared_ptr<FileEntry>& s)
 {
   d->setRequested(true);
   d->setPath(s->getPath());
@@ -77,8 +77,8 @@ void copyValues(const SharedHandle<FileEntry>& d,
 namespace {
 struct EntryCmp {
   bool operator()
-  (const SharedHandle<FileEntry>& lhs,
-   const SharedHandle<FileEntry>& rhs) const
+  (const std::shared_ptr<FileEntry>& lhs,
+   const std::shared_ptr<FileEntry>& rhs) const
   {
     return lhs->getOriginalName() < rhs->getOriginalName();
   }
@@ -91,17 +91,17 @@ bool BtDependency::resolve()
     return true;
   }
   if(dependee_->getNumCommand() == 0 && dependee_->downloadFinished()) {
-    SharedHandle<RequestGroup> dependee = dependee_;
+    std::shared_ptr<RequestGroup> dependee = dependee_;
     // cut reference here
     dependee_.reset();
-    SharedHandle<DownloadContext> context(new DownloadContext());
+    std::shared_ptr<DownloadContext> context(new DownloadContext());
     try {
-      SharedHandle<DiskAdaptor> diskAdaptor =
+      std::shared_ptr<DiskAdaptor> diskAdaptor =
         dependee->getPieceStorage()->getDiskAdaptor();
       diskAdaptor->openExistingFile();
       std::string content = util::toString(diskAdaptor);
       if(dependee->getDownloadContext()->hasAttribute(CTX_ATTR_BT)) {
-        SharedHandle<TorrentAttribute> attrs =
+        std::shared_ptr<TorrentAttribute> attrs =
           bittorrent::getTorrentAttrs(dependee->getDownloadContext());
         bittorrent::loadFromMemory
           (bittorrent::metadata2Torrent(content, attrs), context,
@@ -115,9 +115,9 @@ bool BtDependency::resolve()
         bittorrent::adjustAnnounceUri(bittorrent::getTorrentAttrs(context),
                                       dependant_->getOption());
       }
-      const std::vector<SharedHandle<FileEntry> >& fileEntries =
+      const std::vector<std::shared_ptr<FileEntry> >& fileEntries =
         context->getFileEntries();
-      const std::vector<SharedHandle<FileEntry> >& dependantFileEntries =
+      const std::vector<std::shared_ptr<FileEntry> >& dependantFileEntries =
         dependant_->getDownloadContext()->getFileEntries();
       // If dependant's FileEntry::getOriginalName() is empty, we
       // assume that torrent is single file. In Metalink3, this is
@@ -126,9 +126,9 @@ bool BtDependency::resolve()
          dependantFileEntries[0]->getOriginalName().empty()) {
         copyValues(fileEntries[0], dependantFileEntries[0]);
       } else {
-        std::vector<SharedHandle<FileEntry> > destFiles;
+        std::vector<std::shared_ptr<FileEntry> > destFiles;
         destFiles.reserve(fileEntries.size());
-        for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
+        for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i =
               fileEntries.begin(), eoi = fileEntries.end(); i != eoi; ++i) {
           (*i)->setRequested(false);
           destFiles.push_back(*i);
@@ -137,10 +137,10 @@ bool BtDependency::resolve()
         // Copy file path in dependant_'s FileEntries to newly created
         // context's FileEntries to endorse the path structure of
         // dependant_.  URIs and singleHostMultiConnection are also copied.
-        for(std::vector<SharedHandle<FileEntry> >::const_iterator s =
+        for(std::vector<std::shared_ptr<FileEntry> >::const_iterator s =
               dependantFileEntries.begin(), eoi = dependantFileEntries.end();
             s != eoi; ++s){
-          std::vector<SharedHandle<FileEntry> >::const_iterator d =
+          std::vector<std::shared_ptr<FileEntry> >::const_iterator d =
             std::lower_bound(destFiles.begin(), destFiles.end(), *s,
                              EntryCmp());
           if(d == destFiles.end() ||
diff --git a/src/BtDependency.h b/src/BtDependency.h
index ffb9175b..5f8ba2cb 100644
--- a/src/BtDependency.h
+++ b/src/BtDependency.h
@@ -36,7 +36,8 @@
 #define D_BT_DEPENDENCY_H
 
 #include "Dependency.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -47,10 +48,10 @@ class BtDependency : public Dependency
 {
 private:
   RequestGroup* dependant_;
-  SharedHandle<RequestGroup> dependee_;
+  std::shared_ptr<RequestGroup> dependee_;
 public:
   BtDependency(RequestGroup* dependant,
-               const SharedHandle<RequestGroup>& dependee);
+               const std::shared_ptr<RequestGroup>& dependee);
 
   virtual ~BtDependency();
 
diff --git a/src/BtExtendedMessage.cc b/src/BtExtendedMessage.cc
index c9281be8..faa1934b 100644
--- a/src/BtExtendedMessage.cc
+++ b/src/BtExtendedMessage.cc
@@ -51,7 +51,7 @@ namespace aria2 {
 const char BtExtendedMessage::NAME[] = "extended";
 
 BtExtendedMessage::BtExtendedMessage
-(const SharedHandle<ExtensionMessage>& extensionMessage):
+(const std::shared_ptr<ExtensionMessage>& extensionMessage):
   SimpleBtMessage(ID, NAME),
   extensionMessage_(extensionMessage),
   msgLength_(0)
@@ -97,14 +97,14 @@ std::string BtExtendedMessage::toString() const {
 }
 
 BtExtendedMessage*
-BtExtendedMessage::create(const SharedHandle<ExtensionMessageFactory>& factory,
-                          const SharedHandle<Peer>& peer,
+BtExtendedMessage::create(const std::shared_ptr<ExtensionMessageFactory>& factory,
+                          const std::shared_ptr<Peer>& peer,
                           const unsigned char* data, size_t dataLength)
 {
   bittorrent::assertPayloadLengthGreater(1, dataLength, NAME);
   bittorrent::assertID(ID, data, NAME);
   assert(factory);
-  SharedHandle<ExtensionMessage> extmsg = factory->createMessage(data+1,
+  std::shared_ptr<ExtensionMessage> extmsg = factory->createMessage(data+1,
                                                                  dataLength-1);
   BtExtendedMessage* message(new BtExtendedMessage(extmsg));
   return message;
diff --git a/src/BtExtendedMessage.h b/src/BtExtendedMessage.h
index e4be471b..092b9df5 100644
--- a/src/BtExtendedMessage.h
+++ b/src/BtExtendedMessage.h
@@ -44,12 +44,12 @@ class ExtensionMessageFactory;
 class BtExtendedMessage:public SimpleBtMessage
 {
 private:
-  SharedHandle<ExtensionMessage> extensionMessage_;
+  std::shared_ptr<ExtensionMessage> extensionMessage_;
 
   size_t msgLength_;
 public:
-  BtExtendedMessage(const SharedHandle<ExtensionMessage>& extensionMessage =
-                    SharedHandle<ExtensionMessage>());
+  BtExtendedMessage(const std::shared_ptr<ExtensionMessage>& extensionMessage =
+                    std::shared_ptr<ExtensionMessage>());
   virtual ~BtExtendedMessage();
 
   static const uint8_t ID = 20;
@@ -57,8 +57,8 @@ public:
   static const char NAME[];
 
   static BtExtendedMessage* create
-  (const SharedHandle<ExtensionMessageFactory>& factory,
-   const SharedHandle<Peer>& peer,
+  (const std::shared_ptr<ExtensionMessageFactory>& factory,
+   const std::shared_ptr<Peer>& peer,
    const unsigned char* data,
    size_t dataLength);
 
@@ -72,7 +72,7 @@ public:
 
   virtual std::string toString() const;
 
-  const SharedHandle<ExtensionMessage>& getExtensionMessage() const
+  const std::shared_ptr<ExtensionMessage>& getExtensionMessage() const
   {
     return extensionMessage_;
   }
diff --git a/src/BtFileAllocationEntry.cc b/src/BtFileAllocationEntry.cc
index debeacdc..7b96f1c4 100644
--- a/src/BtFileAllocationEntry.cc
+++ b/src/BtFileAllocationEntry.cc
@@ -67,7 +67,7 @@ void BtFileAllocationEntry::prepareForNextAction
     // For DownloadContext::resetDownloadStartTime(), see also
     // RequestGroup::createInitialCommand()
     getRequestGroup()->getDownloadContext()->resetDownloadStartTime();
-    const std::vector<SharedHandle<FileEntry> >& fileEntries =
+    const std::vector<std::shared_ptr<FileEntry> >& fileEntries =
       getRequestGroup()->getDownloadContext()->getFileEntries();
     if(isUriSuppliedForRequsetFileEntry
        (fileEntries.begin(), fileEntries.end())) {
@@ -75,7 +75,7 @@ void BtFileAllocationEntry::prepareForNextAction
     }
   } else {
 #ifdef __MINGW32__
-    const SharedHandle<DiskAdaptor>& diskAdaptor =
+    const std::shared_ptr<DiskAdaptor>& diskAdaptor =
       getRequestGroup()->getPieceStorage()->getDiskAdaptor();
     if(!diskAdaptor->isReadOnlyEnabled()) {
       // On Windows, if aria2 opens files with GENERIC_WRITE access
diff --git a/src/BtHandshakeMessage.cc b/src/BtHandshakeMessage.cc
index f1968f40..bdc084ce 100644
--- a/src/BtHandshakeMessage.cc
+++ b/src/BtHandshakeMessage.cc
@@ -75,10 +75,10 @@ void BtHandshakeMessage::init() {
   reserved_[5] |= 0x10u;
 }
 
-SharedHandle<BtHandshakeMessage>
+std::shared_ptr<BtHandshakeMessage>
 BtHandshakeMessage::create(const unsigned char* data, size_t dataLength)
 {
-  SharedHandle<BtHandshakeMessage> message(new BtHandshakeMessage());
+  std::shared_ptr<BtHandshakeMessage> message(new BtHandshakeMessage());
   message->pstrlen_ = data[0];
   memcpy(message->pstr_, &data[1], PSTR_LENGTH);
   memcpy(message->reserved_, &data[20], RESERVED_LENGTH);
diff --git a/src/BtHandshakeMessage.h b/src/BtHandshakeMessage.h
index 6da8fa2d..14d967c4 100644
--- a/src/BtHandshakeMessage.h
+++ b/src/BtHandshakeMessage.h
@@ -60,7 +60,7 @@ public:
    */
   BtHandshakeMessage(const unsigned char* infoHash, const unsigned char* peerId);
 
-  static SharedHandle<BtHandshakeMessage>
+  static std::shared_ptr<BtHandshakeMessage>
   create(const unsigned char* data, size_t dataLength);
 
   virtual ~BtHandshakeMessage() {
diff --git a/src/BtInteractive.h b/src/BtInteractive.h
index bec4069f..56cb4e2a 100644
--- a/src/BtInteractive.h
+++ b/src/BtInteractive.h
@@ -36,7 +36,8 @@
 #define D_BT_INTERACTIVE_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -48,9 +49,9 @@ public:
 
   virtual void initiateHandshake() = 0;
 
-  virtual SharedHandle<BtMessage> receiveHandshake(bool quickReply = false) = 0;
+  virtual std::shared_ptr<BtMessage> receiveHandshake(bool quickReply = false) = 0;
 
-  virtual SharedHandle<BtMessage> receiveAndSendHandshake() = 0;
+  virtual std::shared_ptr<BtMessage> receiveAndSendHandshake() = 0;
 
   virtual void doPostHandshakeProcessing() = 0;
 
diff --git a/src/BtInterestedMessage.cc b/src/BtInterestedMessage.cc
index 8fafb399..e70b79b4 100644
--- a/src/BtInterestedMessage.cc
+++ b/src/BtInterestedMessage.cc
@@ -69,7 +69,7 @@ bool BtInterestedMessage::sendPredicate() const
 
 namespace {
 struct ThisProgressUpdate : public ProgressUpdate {
-  ThisProgressUpdate(const SharedHandle<Peer>& peer)
+  ThisProgressUpdate(const std::shared_ptr<Peer>& peer)
     : peer(peer) {}
   virtual void update(size_t length, bool complete)
   {
@@ -77,7 +77,7 @@ struct ThisProgressUpdate : public ProgressUpdate {
       peer->amInterested(true);
     }
   }
-  SharedHandle<Peer> peer;
+  std::shared_ptr<Peer> peer;
 };
 } // namespace
 
@@ -87,7 +87,7 @@ ProgressUpdate* BtInterestedMessage::getProgressUpdate()
 }
 
 void BtInterestedMessage::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
diff --git a/src/BtInterestedMessage.h b/src/BtInterestedMessage.h
index bc10b208..392086f3 100644
--- a/src/BtInterestedMessage.h
+++ b/src/BtInterestedMessage.h
@@ -44,7 +44,7 @@ class BtInterestedMessage;
 
 class BtInterestedMessage : public ZeroBtMessage {
 private:
-  SharedHandle<PeerStorage> peerStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
 public:
   BtInterestedMessage();
   virtual ~BtInterestedMessage();
@@ -62,7 +62,7 @@ public:
 
   virtual ProgressUpdate* getProgressUpdate();
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 };
 
 } // namespace aria2
diff --git a/src/BtLeecherStateChoke.cc b/src/BtLeecherStateChoke.cc
index 1442d46a..7707ea55 100644
--- a/src/BtLeecherStateChoke.cc
+++ b/src/BtLeecherStateChoke.cc
@@ -52,7 +52,7 @@ BtLeecherStateChoke::BtLeecherStateChoke()
 
 BtLeecherStateChoke::~BtLeecherStateChoke() {}
 
-BtLeecherStateChoke::PeerEntry::PeerEntry(const SharedHandle<Peer>& peer):
+BtLeecherStateChoke::PeerEntry::PeerEntry(const std::shared_ptr<Peer>& peer):
   peer_(peer), downloadSpeed_(peer->calculateDownloadSpeed()),
   // peer must be interested to us and sent block in the last 30 seconds
   regularUnchoker_
@@ -86,7 +86,7 @@ BtLeecherStateChoke::PeerEntry& BtLeecherStateChoke::PeerEntry::operator=
 
 BtLeecherStateChoke::PeerEntry::~PeerEntry() {}
 
-const SharedHandle<Peer>& BtLeecherStateChoke::PeerEntry::getPeer() const
+const std::shared_ptr<Peer>& BtLeecherStateChoke::PeerEntry::getPeer() const
 {
   return peer_;
 }
diff --git a/src/BtLeecherStateChoke.h b/src/BtLeecherStateChoke.h
index 64c191fe..cfe0cfc0 100644
--- a/src/BtLeecherStateChoke.h
+++ b/src/BtLeecherStateChoke.h
@@ -38,8 +38,8 @@
 #include "common.h"
 
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimerA2.h"
 #include "PeerStorage.h"
 
@@ -55,11 +55,11 @@ private:
 
   class PeerEntry {
   private:
-    SharedHandle<Peer> peer_;
+    std::shared_ptr<Peer> peer_;
     int downloadSpeed_;
     bool regularUnchoker_;
   public:
-    PeerEntry(const SharedHandle<Peer>& peer);
+    PeerEntry(const std::shared_ptr<Peer>& peer);
     PeerEntry(const PeerEntry& c);
     ~PeerEntry();
 
@@ -69,7 +69,7 @@ private:
 
     void swap(PeerEntry& c);
 
-    const SharedHandle<Peer>& getPeer() const;
+    const std::shared_ptr<Peer>& getPeer() const;
 
     int getDownloadSpeed() const;
 
diff --git a/src/BtMessageDispatcher.h b/src/BtMessageDispatcher.h
index 24234f9a..ed4c0bb7 100644
--- a/src/BtMessageDispatcher.h
+++ b/src/BtMessageDispatcher.h
@@ -38,8 +38,8 @@
 #include "common.h"
 
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "RequestSlot.h"
 
 namespace aria2 {
@@ -51,19 +51,19 @@ class BtMessageDispatcher {
 public:
   virtual ~BtMessageDispatcher() {}
 
-  virtual void addMessageToQueue(const SharedHandle<BtMessage>& btMessage) = 0;
+  virtual void addMessageToQueue(const std::shared_ptr<BtMessage>& btMessage) = 0;
 
   virtual void
-  addMessageToQueue(const std::vector<SharedHandle<BtMessage> >& btMessages) =0;
+  addMessageToQueue(const std::vector<std::shared_ptr<BtMessage> >& btMessages) =0;
 
   virtual void sendMessages() = 0;
 
   virtual void doCancelSendingPieceAction
   (size_t index, int32_t begin, int32_t length) = 0;
 
-  virtual void doCancelSendingPieceAction(const SharedHandle<Piece>& piece) = 0;
+  virtual void doCancelSendingPieceAction(const std::shared_ptr<Piece>& piece) = 0;
 
-  virtual void doAbortOutstandingRequestAction(const SharedHandle<Piece>& piece) = 0;
+  virtual void doAbortOutstandingRequestAction(const std::shared_ptr<Piece>& piece) = 0;
 
   virtual void doChokedAction() = 0;
 
diff --git a/src/BtMessageFactory.h b/src/BtMessageFactory.h
index 963b373c..cb244d9b 100644
--- a/src/BtMessageFactory.h
+++ b/src/BtMessageFactory.h
@@ -36,7 +36,8 @@
 #define D_BT_MESSAGE_FACTORY_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -49,52 +50,52 @@ class BtMessageFactory {
 public:
   virtual ~BtMessageFactory() {}
 
-  virtual SharedHandle<BtMessage>
+  virtual std::shared_ptr<BtMessage>
   createBtMessage(const unsigned char* msg, size_t msgLength) = 0;
 
-  virtual SharedHandle<BtHandshakeMessage>
+  virtual std::shared_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* msg, size_t msgLength) = 0;
 
-  virtual SharedHandle<BtHandshakeMessage>
+  virtual std::shared_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* infoHash,
                          const unsigned char* peerId) = 0;
 
-  virtual SharedHandle<BtMessage>
-  createRequestMessage(const SharedHandle<Piece>& piece, size_t blockIndex) = 0;
+  virtual std::shared_ptr<BtMessage>
+  createRequestMessage(const std::shared_ptr<Piece>& piece, size_t blockIndex) = 0;
 
-  virtual SharedHandle<BtMessage>
+  virtual std::shared_ptr<BtMessage>
   createCancelMessage(size_t index, int32_t begin, int32_t length) = 0;
 
-  virtual SharedHandle<BtMessage>
+  virtual std::shared_ptr<BtMessage>
   createPieceMessage(size_t index, int32_t begin, int32_t length) = 0;
 
-  virtual SharedHandle<BtMessage> createHaveMessage(size_t index) = 0;
+  virtual std::shared_ptr<BtMessage> createHaveMessage(size_t index) = 0;
 
-  virtual SharedHandle<BtMessage> createChokeMessage() = 0;
+  virtual std::shared_ptr<BtMessage> createChokeMessage() = 0;
 
-  virtual SharedHandle<BtMessage> createUnchokeMessage() = 0;
+  virtual std::shared_ptr<BtMessage> createUnchokeMessage() = 0;
 
-  virtual SharedHandle<BtMessage> createInterestedMessage() = 0;
+  virtual std::shared_ptr<BtMessage> createInterestedMessage() = 0;
 
-  virtual SharedHandle<BtMessage> createNotInterestedMessage() = 0;
+  virtual std::shared_ptr<BtMessage> createNotInterestedMessage() = 0;
 
-  virtual SharedHandle<BtMessage> createBitfieldMessage() = 0;
+  virtual std::shared_ptr<BtMessage> createBitfieldMessage() = 0;
 
-  virtual SharedHandle<BtMessage> createKeepAliveMessage() = 0;
+  virtual std::shared_ptr<BtMessage> createKeepAliveMessage() = 0;
 
-  virtual SharedHandle<BtMessage> createHaveAllMessage() = 0;
+  virtual std::shared_ptr<BtMessage> createHaveAllMessage() = 0;
 
-  virtual SharedHandle<BtMessage> createHaveNoneMessage() = 0;
+  virtual std::shared_ptr<BtMessage> createHaveNoneMessage() = 0;
 
-  virtual SharedHandle<BtMessage>
+  virtual std::shared_ptr<BtMessage>
   createRejectMessage(size_t index, int32_t begin, int32_t length) = 0;
 
-  virtual SharedHandle<BtMessage> createAllowedFastMessage(size_t index) = 0;
+  virtual std::shared_ptr<BtMessage> createAllowedFastMessage(size_t index) = 0;
 
-  virtual SharedHandle<BtMessage> createPortMessage(uint16_t port) = 0;
+  virtual std::shared_ptr<BtMessage> createPortMessage(uint16_t port) = 0;
 
-  virtual SharedHandle<BtMessage>
-  createBtExtendedMessage(const SharedHandle<ExtensionMessage>& msg) = 0;
+  virtual std::shared_ptr<BtMessage>
+  createBtExtendedMessage(const std::shared_ptr<ExtensionMessage>& msg) = 0;
 };
 
 } // namespace aria2
diff --git a/src/BtMessageReceiver.h b/src/BtMessageReceiver.h
index f9500b3d..4a7ef23c 100644
--- a/src/BtMessageReceiver.h
+++ b/src/BtMessageReceiver.h
@@ -36,7 +36,8 @@
 #define D_BT_MESSAGE_RECEIVER_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -47,11 +48,11 @@ class BtMessageReceiver {
 public:
   virtual ~BtMessageReceiver() {}
 
-  virtual SharedHandle<BtHandshakeMessage> receiveHandshake(bool quickReply = false) = 0;
+  virtual std::shared_ptr<BtHandshakeMessage> receiveHandshake(bool quickReply = false) = 0;
 
-  virtual SharedHandle<BtHandshakeMessage> receiveAndSendHandshake() = 0;
+  virtual std::shared_ptr<BtHandshakeMessage> receiveAndSendHandshake() = 0;
 
-  virtual SharedHandle<BtMessage> receiveMessage() = 0;
+  virtual std::shared_ptr<BtMessage> receiveMessage() = 0;
 };
 
 } // namespace aria2
diff --git a/src/BtNotInterestedMessage.cc b/src/BtNotInterestedMessage.cc
index 60b810a4..eca078d5 100644
--- a/src/BtNotInterestedMessage.cc
+++ b/src/BtNotInterestedMessage.cc
@@ -69,7 +69,7 @@ bool BtNotInterestedMessage::sendPredicate() const
 
 namespace {
 struct ThisProgressUpdate : public ProgressUpdate {
-  ThisProgressUpdate(const SharedHandle<Peer>& peer)
+  ThisProgressUpdate(const std::shared_ptr<Peer>& peer)
     : peer(peer) {}
   virtual void update(size_t length, bool complete)
   {
@@ -77,7 +77,7 @@ struct ThisProgressUpdate : public ProgressUpdate {
       peer->amInterested(false);
     }
   }
-  SharedHandle<Peer> peer;
+  std::shared_ptr<Peer> peer;
 };
 } // namespace
 
@@ -87,7 +87,7 @@ ProgressUpdate* BtNotInterestedMessage::getProgressUpdate()
 }
 
 void BtNotInterestedMessage::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
diff --git a/src/BtNotInterestedMessage.h b/src/BtNotInterestedMessage.h
index fd9a5844..0a1f4fd7 100644
--- a/src/BtNotInterestedMessage.h
+++ b/src/BtNotInterestedMessage.h
@@ -44,7 +44,7 @@ class BtNotInterestedMessage;
 
 class BtNotInterestedMessage : public ZeroBtMessage {
 private:
-  SharedHandle<PeerStorage> peerStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
 public:
   BtNotInterestedMessage();
   virtual ~BtNotInterestedMessage();
@@ -62,7 +62,7 @@ public:
 
   virtual ProgressUpdate* getProgressUpdate();
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 };
 
 } // namespace aria2
diff --git a/src/BtPieceMessage.cc b/src/BtPieceMessage.cc
index 04025f48..c0abf66b 100644
--- a/src/BtPieceMessage.cc
+++ b/src/BtPieceMessage.cc
@@ -107,7 +107,7 @@ void BtPieceMessage::doReceivedAction()
   downloadContext_->updateDownloadLength(blockLength_);
   if(!RequestSlot::isNull(slot)) {
     getPeer()->snubbing(false);
-    SharedHandle<Piece> piece = getPieceStorage()->getPiece(index_);
+    std::shared_ptr<Piece> piece = getPieceStorage()->getPiece(index_);
     int64_t offset =
       static_cast<int64_t>(index_)*downloadContext_->getPieceLength()+begin_;
     A2_LOG_DEBUG(fmt(MSG_PIECE_RECEIVED,
@@ -179,7 +179,7 @@ size_t BtPieceMessage::getMessageHeaderLength()
 
 namespace {
 struct PieceSendUpdate : public ProgressUpdate {
-  PieceSendUpdate(const SharedHandle<Peer>& peer, size_t headerLength)
+  PieceSendUpdate(const std::shared_ptr<Peer>& peer, size_t headerLength)
     : peer(peer), headerLength(headerLength) {}
   virtual void update(size_t length, bool complete)
   {
@@ -190,7 +190,7 @@ struct PieceSendUpdate : public ProgressUpdate {
     }
     peer->updateUploadLength(length);
   }
-  SharedHandle<Peer> peer;
+  std::shared_ptr<Peer> peer;
   size_t headerLength;
 };
 } // namespace
@@ -241,7 +241,7 @@ std::string BtPieceMessage::toString() const
              begin_, blockLength_);
 }
 
-bool BtPieceMessage::checkPieceHash(const SharedHandle<Piece>& piece)
+bool BtPieceMessage::checkPieceHash(const std::shared_ptr<Piece>& piece)
 {
   if(!getPieceStorage()->isEndGame() && piece->isHashCalculated()) {
     A2_LOG_DEBUG(fmt("Hash is available!! index=%lu",
@@ -262,7 +262,7 @@ bool BtPieceMessage::checkPieceHash(const SharedHandle<Piece>& piece)
   }
 }
 
-void BtPieceMessage::onNewPiece(const SharedHandle<Piece>& piece)
+void BtPieceMessage::onNewPiece(const std::shared_ptr<Piece>& piece)
 {
   if(piece->getWrDiskCacheEntry()) {
     // We flush cached data whenever an whole piece is retrieved.
@@ -283,7 +283,7 @@ void BtPieceMessage::onNewPiece(const SharedHandle<Piece>& piece)
   getPieceStorage()->advertisePiece(getCuid(), piece->getIndex());
 }
 
-void BtPieceMessage::onWrongPiece(const SharedHandle<Piece>& piece)
+void BtPieceMessage::onWrongPiece(const std::shared_ptr<Piece>& piece)
 {
   A2_LOG_INFO(fmt(MSG_GOT_WRONG_PIECE,
                   getCuid(),
@@ -303,7 +303,7 @@ void BtPieceMessage::onChokingEvent(const BtChokingEvent& event)
                      begin_,
                      blockLength_));
     if(getPeer()->isFastExtensionEnabled()) {
-      SharedHandle<BtMessage> rej =
+      std::shared_ptr<BtMessage> rej =
         getBtMessageFactory()->createRejectMessage
         (index_, begin_, blockLength_);
       getBtMessageDispatcher()->addMessageToQueue(rej);
@@ -325,7 +325,7 @@ void BtPieceMessage::onCancelSendingPieceEvent
                      begin_,
                      blockLength_));
     if(getPeer()->isFastExtensionEnabled()) {
-      SharedHandle<BtMessage> rej =
+      std::shared_ptr<BtMessage> rej =
         getBtMessageFactory()->createRejectMessage
         (index_, begin_, blockLength_);
       getBtMessageDispatcher()->addMessageToQueue(rej);
@@ -335,13 +335,13 @@ void BtPieceMessage::onCancelSendingPieceEvent
 }
 
 void BtPieceMessage::setDownloadContext
-(const SharedHandle<DownloadContext>& downloadContext)
+(const std::shared_ptr<DownloadContext>& downloadContext)
 {
   downloadContext_ = downloadContext;
 }
 
 void BtPieceMessage::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
diff --git a/src/BtPieceMessage.h b/src/BtPieceMessage.h
index 09fef7dc..d6488ba2 100644
--- a/src/BtPieceMessage.h
+++ b/src/BtPieceMessage.h
@@ -49,16 +49,16 @@ private:
   int32_t begin_;
   int32_t blockLength_;
   const unsigned char* data_;
-  SharedHandle<DownloadContext> downloadContext_;
-  SharedHandle<PeerStorage> peerStorage_;
+  std::shared_ptr<DownloadContext> downloadContext_;
+  std::shared_ptr<PeerStorage> peerStorage_;
 
   static size_t MESSAGE_HEADER_LENGTH;
 
-  bool checkPieceHash(const SharedHandle<Piece>& piece);
+  bool checkPieceHash(const std::shared_ptr<Piece>& piece);
 
-  void onNewPiece(const SharedHandle<Piece>& piece);
+  void onNewPiece(const std::shared_ptr<Piece>& piece);
 
-  void onWrongPiece(const SharedHandle<Piece>& piece);
+  void onWrongPiece(const std::shared_ptr<Piece>& piece);
 
   void pushPieceData(int64_t offset, int32_t length) const;
 public:
@@ -88,9 +88,9 @@ public:
 
   void setBlockLength(int32_t blockLength) { blockLength_ = blockLength; }
 
-  void setDownloadContext(const SharedHandle<DownloadContext>& downloadContext);
+  void setDownloadContext(const std::shared_ptr<DownloadContext>& downloadContext);
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 
   static BtPieceMessage* create(const unsigned char* data, size_t dataLength);
 
diff --git a/src/BtPortMessage.cc b/src/BtPortMessage.cc
index 2d241d49..95e6e0bd 100644
--- a/src/BtPortMessage.cc
+++ b/src/BtPortMessage.cc
@@ -80,11 +80,11 @@ void BtPortMessage::doReceivedAction()
     }
     // 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.
-    SharedHandle<DHTNode> node(new DHTNode());
+    std::shared_ptr<DHTNode> node(new DHTNode());
     node->setIPAddress(getPeer()->getIPAddress());
     node->setPort(port_);
     {
-      SharedHandle<DHTTask> task = taskFactory_->createPingTask(node);
+      std::shared_ptr<DHTTask> task = taskFactory_->createPingTask(node);
       taskQueue_->addImmediateTask(task);
     }
     if(routingTable_->getNumBucket() == 1) {
diff --git a/src/BtPostDownloadHandler.cc b/src/BtPostDownloadHandler.cc
index 614b0c69..9c432192 100644
--- a/src/BtPostDownloadHandler.cc
+++ b/src/BtPostDownloadHandler.cc
@@ -57,7 +57,7 @@ namespace aria2 {
 
 BtPostDownloadHandler::BtPostDownloadHandler()
 {
-  SharedHandle<RequestGroupCriteria> cri
+  std::shared_ptr<RequestGroupCriteria> cri
     (new ContentTypeRequestGroupCriteria
      (getBtContentTypes(), getBtExtensions()));
   setCriteria(cri);
@@ -66,18 +66,18 @@ BtPostDownloadHandler::BtPostDownloadHandler()
 BtPostDownloadHandler::~BtPostDownloadHandler() {}
 
 void BtPostDownloadHandler::getNextRequestGroups
-(std::vector<SharedHandle<RequestGroup> >& groups,
+(std::vector<std::shared_ptr<RequestGroup> >& groups,
  RequestGroup* requestGroup)
 {
   A2_LOG_INFO(fmt("Generating RequestGroups for Torrent file %s",
                   requestGroup->getFirstFilePath().c_str()));
-  SharedHandle<ValueBase> torrent;
+  std::shared_ptr<ValueBase> torrent;
   if(requestGroup->inMemoryDownload()) {
-    const SharedHandle<DiskWriter>& dw =
-      static_pointer_cast<AbstractSingleDiskAdaptor>
+    const std::shared_ptr<DiskWriter>& dw =
+      std::static_pointer_cast<AbstractSingleDiskAdaptor>
       (requestGroup->getPieceStorage()->getDiskAdaptor())->getDiskWriter();
-    const SharedHandle<bittorrent::BencodeDiskWriter>& bdw =
-      static_pointer_cast<bittorrent::BencodeDiskWriter>(dw);
+    const std::shared_ptr<bittorrent::BencodeDiskWriter>& bdw =
+      std::static_pointer_cast<bittorrent::BencodeDiskWriter>(dw);
     int error = bdw->finalize();
     if(error == 0) {
       torrent = bdw->getResult();
@@ -101,13 +101,13 @@ void BtPostDownloadHandler::getNextRequestGroups
     throw DL_ABORT_EX2("Could not parse BitTorrent metainfo",
                        error_code::BENCODE_PARSE_ERROR);
   }
-  std::vector<SharedHandle<RequestGroup> > newRgs;
+  std::vector<std::shared_ptr<RequestGroup> > newRgs;
   createRequestGroupForBitTorrent(newRgs, requestGroup->getOption(),
                                   std::vector<std::string>(),
                                   "",
                                   torrent);
   requestGroup->followedBy(newRgs.begin(), newRgs.end());
-  SharedHandle<MetadataInfo> mi =
+  std::shared_ptr<MetadataInfo> mi =
     createMetadataInfoFromFirstFileEntry(requestGroup->getGroupId(),
                                          requestGroup->getDownloadContext());
   if(mi) {
diff --git a/src/BtPostDownloadHandler.h b/src/BtPostDownloadHandler.h
index 7ff75520..4ddfddd6 100644
--- a/src/BtPostDownloadHandler.h
+++ b/src/BtPostDownloadHandler.h
@@ -47,7 +47,7 @@ public:
   virtual ~BtPostDownloadHandler();
 
   virtual void
-  getNextRequestGroups(std::vector<SharedHandle<RequestGroup> >& groups,
+  getNextRequestGroups(std::vector<std::shared_ptr<RequestGroup> >& groups,
                        RequestGroup* requestGroup);
 };
 
diff --git a/src/BtRegistry.cc b/src/BtRegistry.cc
index 273f0130..f38fd19f 100644
--- a/src/BtRegistry.cc
+++ b/src/BtRegistry.cc
@@ -54,10 +54,10 @@ BtRegistry::BtRegistry()
 
 BtRegistry::~BtRegistry() {}
 
-const SharedHandle<DownloadContext>&
+const std::shared_ptr<DownloadContext>&
 BtRegistry::getDownloadContext(a2_gid_t gid) const
 {
-  const SharedHandle<BtObject>& res = get(gid);
+  const std::shared_ptr<BtObject>& res = get(gid);
   if(res) {
     return res->downloadContext;
   } else {
@@ -65,10 +65,10 @@ BtRegistry::getDownloadContext(a2_gid_t gid) const
   }
 }
 
-const SharedHandle<DownloadContext>&
+const std::shared_ptr<DownloadContext>&
 BtRegistry::getDownloadContext(const std::string& infoHash) const
 {
-  for(std::map<a2_gid_t, SharedHandle<BtObject> >::const_iterator i =
+  for(std::map<a2_gid_t, std::shared_ptr<BtObject> >::const_iterator i =
         pool_.begin(), eoi = pool_.end(); i != eoi; ++i) {
     if(bittorrent::getTorrentAttrs((*i).second->downloadContext)->infoHash ==
        infoHash) {
@@ -78,14 +78,14 @@ BtRegistry::getDownloadContext(const std::string& infoHash) const
   return getNull<DownloadContext>();
 }
 
-void BtRegistry::put(a2_gid_t gid, const SharedHandle<BtObject>& obj)
+void BtRegistry::put(a2_gid_t gid, const std::shared_ptr<BtObject>& obj)
 {
   pool_[gid] = obj;
 }
 
-const SharedHandle<BtObject>& BtRegistry::get(a2_gid_t gid) const
+const std::shared_ptr<BtObject>& BtRegistry::get(a2_gid_t gid) const
 {
-  std::map<a2_gid_t, SharedHandle<BtObject> >::const_iterator i =
+  std::map<a2_gid_t, std::shared_ptr<BtObject> >::const_iterator i =
     pool_.find(gid);
   if(i == pool_.end()) {
     return getNull<BtObject>();
@@ -104,24 +104,24 @@ void BtRegistry::removeAll() {
 }
 
 void BtRegistry::setLpdMessageReceiver
-(const SharedHandle<LpdMessageReceiver>& receiver)
+(const std::shared_ptr<LpdMessageReceiver>& receiver)
 {
   lpdMessageReceiver_ = receiver;
 }
 
 void BtRegistry::setUDPTrackerClient
-(const SharedHandle<UDPTrackerClient>& tracker)
+(const std::shared_ptr<UDPTrackerClient>& tracker)
 {
   udpTrackerClient_ = tracker;
 }
 
 BtObject::BtObject
-(const SharedHandle<DownloadContext>& downloadContext,
- const SharedHandle<PieceStorage>& pieceStorage,
- const SharedHandle<PeerStorage>& peerStorage,
- const SharedHandle<BtAnnounce>& btAnnounce,
- const SharedHandle<BtRuntime>& btRuntime,
- const SharedHandle<BtProgressInfoFile>& btProgressInfoFile)
+(const std::shared_ptr<DownloadContext>& downloadContext,
+ const std::shared_ptr<PieceStorage>& pieceStorage,
+ const std::shared_ptr<PeerStorage>& peerStorage,
+ const std::shared_ptr<BtAnnounce>& btAnnounce,
+ const std::shared_ptr<BtRuntime>& btRuntime,
+ const std::shared_ptr<BtProgressInfoFile>& btProgressInfoFile)
   : downloadContext(downloadContext),
     pieceStorage(pieceStorage),
     peerStorage(peerStorage),
diff --git a/src/BtRegistry.h b/src/BtRegistry.h
index ea980a2a..052bcd16 100644
--- a/src/BtRegistry.h
+++ b/src/BtRegistry.h
@@ -38,8 +38,8 @@
 #include "common.h"
 
 #include <map>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "RequestGroup.h"
 
 namespace aria2 {
@@ -54,19 +54,19 @@ class LpdMessageReceiver;
 class UDPTrackerClient;
 
 struct BtObject {
-  SharedHandle<DownloadContext> downloadContext;
-  SharedHandle<PieceStorage> pieceStorage;
-  SharedHandle<PeerStorage> peerStorage;
-  SharedHandle<BtAnnounce> btAnnounce;
-  SharedHandle<BtRuntime> btRuntime;
-  SharedHandle<BtProgressInfoFile> btProgressInfoFile;
+  std::shared_ptr<DownloadContext> downloadContext;
+  std::shared_ptr<PieceStorage> pieceStorage;
+  std::shared_ptr<PeerStorage> peerStorage;
+  std::shared_ptr<BtAnnounce> btAnnounce;
+  std::shared_ptr<BtRuntime> btRuntime;
+  std::shared_ptr<BtProgressInfoFile> btProgressInfoFile;
 
-  BtObject(const SharedHandle<DownloadContext>& downloadContext,
-           const SharedHandle<PieceStorage>& pieceStorage,
-           const SharedHandle<PeerStorage>& peerStorage,
-           const SharedHandle<BtAnnounce>& btAnnounce,
-           const SharedHandle<BtRuntime>& btRuntime,
-           const SharedHandle<BtProgressInfoFile>& btProgressInfoFile);
+  BtObject(const std::shared_ptr<DownloadContext>& downloadContext,
+           const std::shared_ptr<PieceStorage>& pieceStorage,
+           const std::shared_ptr<PeerStorage>& peerStorage,
+           const std::shared_ptr<BtAnnounce>& btAnnounce,
+           const std::shared_ptr<BtRuntime>& btRuntime,
+           const std::shared_ptr<BtProgressInfoFile>& btProgressInfoFile);
 
   BtObject();
 
@@ -79,31 +79,31 @@ struct BtObject {
 
 class BtRegistry {
 private:
-  std::map<a2_gid_t, SharedHandle<BtObject> > pool_;
+  std::map<a2_gid_t, std::shared_ptr<BtObject> > pool_;
   uint16_t tcpPort_;
   // This is UDP port for DHT and UDP tracker. But currently UDP
   // tracker is not supported in IPv6.
   uint16_t udpPort_;
-  SharedHandle<LpdMessageReceiver> lpdMessageReceiver_;
-  SharedHandle<UDPTrackerClient> udpTrackerClient_;
+  std::shared_ptr<LpdMessageReceiver> lpdMessageReceiver_;
+  std::shared_ptr<UDPTrackerClient> udpTrackerClient_;
 public:
   BtRegistry();
   ~BtRegistry();
 
-  const SharedHandle<DownloadContext>&
+  const std::shared_ptr<DownloadContext>&
   getDownloadContext(a2_gid_t gid) const;
 
-  const SharedHandle<DownloadContext>&
+  const std::shared_ptr<DownloadContext>&
   getDownloadContext(const std::string& infoHash) const;
 
-  void put(a2_gid_t gid, const SharedHandle<BtObject>& obj);
+  void put(a2_gid_t gid, const std::shared_ptr<BtObject>& obj);
 
-  const SharedHandle<BtObject>& get(a2_gid_t gid) const;
+  const std::shared_ptr<BtObject>& get(a2_gid_t gid) const;
 
   template<typename OutputIterator>
   OutputIterator getAllDownloadContext(OutputIterator dest)
   {
-    for(std::map<a2_gid_t, SharedHandle<BtObject> >::const_iterator i =
+    for(std::map<a2_gid_t, std::shared_ptr<BtObject> >::const_iterator i =
           pool_.begin(), eoi = pool_.end(); i != eoi; ++i) {
       *dest++ = (*i).second->downloadContext;
     }
@@ -132,14 +132,14 @@ public:
     return udpPort_;
   }
 
-  void setLpdMessageReceiver(const SharedHandle<LpdMessageReceiver>& receiver);
-  const SharedHandle<LpdMessageReceiver>& getLpdMessageReceiver() const
+  void setLpdMessageReceiver(const std::shared_ptr<LpdMessageReceiver>& receiver);
+  const std::shared_ptr<LpdMessageReceiver>& getLpdMessageReceiver() const
   {
     return lpdMessageReceiver_;
   }
 
-  void setUDPTrackerClient(const SharedHandle<UDPTrackerClient>& tracker);
-  const SharedHandle<UDPTrackerClient>& getUDPTrackerClient() const
+  void setUDPTrackerClient(const std::shared_ptr<UDPTrackerClient>& tracker);
+  const std::shared_ptr<UDPTrackerClient>& getUDPTrackerClient() const
   {
     return udpTrackerClient_;
   }
diff --git a/src/BtRequestFactory.h b/src/BtRequestFactory.h
index b1f58ad3..1e77f34d 100644
--- a/src/BtRequestFactory.h
+++ b/src/BtRequestFactory.h
@@ -38,8 +38,7 @@
 #include "common.h"
 
 #include <vector>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -50,9 +49,9 @@ class BtRequestFactory {
 public:
   virtual ~BtRequestFactory() {}
 
-  virtual void addTargetPiece(const SharedHandle<Piece>& piece) = 0;
+  virtual void addTargetPiece(const std::shared_ptr<Piece>& piece) = 0;
 
-  virtual void removeTargetPiece(const SharedHandle<Piece>& piece) = 0;
+  virtual void removeTargetPiece(const std::shared_ptr<Piece>& piece) = 0;
 
   virtual void removeAllTargetPiece() = 0;
 
@@ -70,14 +69,14 @@ public:
    * The number of objects returned is capped by max.
    */
   virtual void createRequestMessages
-  (std::vector<SharedHandle<BtMessage> >& requests, size_t max) = 0;
+  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max) = 0;
 
   /**
    * Use this method in end game mode.
    *
    */
   virtual void createRequestMessagesOnEndGame
-  (std::vector<SharedHandle<BtMessage> >& requests, size_t max) = 0;
+  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max) = 0;
 
   /**
    * Stores the list of index of pieces added using addTargetPiece() into
diff --git a/src/BtRequestMessage.cc b/src/BtRequestMessage.cc
index 34473bf3..236b40d3 100644
--- a/src/BtRequestMessage.cc
+++ b/src/BtRequestMessage.cc
@@ -63,13 +63,13 @@ void BtRequestMessage::doReceivedAction()
      (!getPeer()->amChoking() ||
       (getPeer()->amChoking() &&
        getPeer()->isInAmAllowedIndexSet(getIndex())))) {
-    SharedHandle<BtMessage> msg =
+    std::shared_ptr<BtMessage> msg =
       getBtMessageFactory()->createPieceMessage
       (getIndex(), getBegin(), getLength());
     getBtMessageDispatcher()->addMessageToQueue(msg);
   } else {
     if(getPeer()->isFastExtensionEnabled()) {
-      SharedHandle<BtMessage> msg =
+      std::shared_ptr<BtMessage> msg =
         getBtMessageFactory()->createRejectMessage
         (getIndex(), getBegin(), getLength());
       getBtMessageDispatcher()->addMessageToQueue(msg);
diff --git a/src/BtSeederStateChoke.cc b/src/BtSeederStateChoke.cc
index 57a96609..7b1439f8 100644
--- a/src/BtSeederStateChoke.cc
+++ b/src/BtSeederStateChoke.cc
@@ -53,7 +53,7 @@ BtSeederStateChoke::BtSeederStateChoke()
 BtSeederStateChoke::~BtSeederStateChoke() {}
 
 BtSeederStateChoke::PeerEntry::PeerEntry
-(const SharedHandle<Peer>& peer):
+(const std::shared_ptr<Peer>& peer):
   peer_(peer),
   outstandingUpload_(peer->countOutstandingUpload()),
   lastAmUnchoking_(peer->getLastAmUnchoking()),
diff --git a/src/BtSeederStateChoke.h b/src/BtSeederStateChoke.h
index 5d7a6d35..c7342d52 100644
--- a/src/BtSeederStateChoke.h
+++ b/src/BtSeederStateChoke.h
@@ -38,8 +38,8 @@
 #include "common.h"
 
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimerA2.h"
 #include "PeerStorage.h"
 
@@ -55,7 +55,7 @@ private:
 
   class PeerEntry {
   private:
-    SharedHandle<Peer> peer_;
+    std::shared_ptr<Peer> peer_;
     size_t outstandingUpload_;
     Timer lastAmUnchoking_;
     bool recentUnchoking_;
@@ -63,7 +63,7 @@ private:
 
     const static time_t TIME_FRAME = 20;
   public:
-    PeerEntry(const SharedHandle<Peer>& peer);
+    PeerEntry(const std::shared_ptr<Peer>& peer);
     PeerEntry(const PeerEntry& c);
     ~PeerEntry();
 
@@ -73,7 +73,7 @@ private:
 
     bool operator<(const PeerEntry& rhs) const;
 
-    const SharedHandle<Peer>& getPeer() const { return peer_; }
+    const std::shared_ptr<Peer>& getPeer() const { return peer_; }
 
     int getUploadSpeed() const { return uploadSpeed_; }
 
diff --git a/src/BtSetup.cc b/src/BtSetup.cc
index 50c52ef3..43457d86 100644
--- a/src/BtSetup.cc
+++ b/src/BtSetup.cc
@@ -98,15 +98,15 @@ void BtSetup::setup(std::vector<Command*>& commands,
   if(!requestGroup->getDownloadContext()->hasAttribute(CTX_ATTR_BT)){
     return;
   }
-  SharedHandle<TorrentAttribute> torrentAttrs =
+  std::shared_ptr<TorrentAttribute> torrentAttrs =
     bittorrent::getTorrentAttrs(requestGroup->getDownloadContext());
   bool metadataGetMode = torrentAttrs->metadata.empty();
-  const SharedHandle<BtRegistry>& btReg = e->getBtRegistry();
-  const SharedHandle<BtObject>& btObject = btReg->get(requestGroup->getGID());
-  const SharedHandle<PieceStorage>& pieceStorage = btObject->pieceStorage;
-  const SharedHandle<PeerStorage>& peerStorage = btObject->peerStorage;
-  const SharedHandle<BtRuntime>& btRuntime = btObject->btRuntime;
-  const SharedHandle<BtAnnounce>& btAnnounce = btObject->btAnnounce;
+  const std::shared_ptr<BtRegistry>& btReg = e->getBtRegistry();
+  const std::shared_ptr<BtObject>& btObject = btReg->get(requestGroup->getGID());
+  const std::shared_ptr<PieceStorage>& pieceStorage = btObject->pieceStorage;
+  const std::shared_ptr<PeerStorage>& peerStorage = btObject->peerStorage;
+  const std::shared_ptr<BtRuntime>& btRuntime = btObject->btRuntime;
+  const std::shared_ptr<BtAnnounce>& btAnnounce = btObject->btAnnounce;
   // commands
   {
     TrackerWatcherCommand* c =
@@ -159,16 +159,16 @@ void BtSetup::setup(std::vector<Command*>& commands,
     }
   }
   if(!metadataGetMode) {
-    SharedHandle<UnionSeedCriteria> unionCri(new UnionSeedCriteria());
+    std::shared_ptr<UnionSeedCriteria> unionCri(new UnionSeedCriteria());
     if(option->defined(PREF_SEED_TIME)) {
-      SharedHandle<SeedCriteria> cri
+      std::shared_ptr<SeedCriteria> cri
         (new TimeSeedCriteria(option->getAsInt(PREF_SEED_TIME)*60));
       unionCri->addSeedCriteria(cri);
     }
     {
       double ratio = option->getAsDouble(PREF_SEED_RATIO);
       if(ratio > 0.0) {
-        SharedHandle<ShareRatioSeedCriteria> cri
+        std::shared_ptr<ShareRatioSeedCriteria> cri
           (new ShareRatioSeedCriteria(option->getAsDouble(PREF_SEED_RATIO),
                                       requestGroup->getDownloadContext()));
         cri->setPieceStorage(pieceStorage);
@@ -223,7 +223,7 @@ void BtSetup::setup(std::vector<Command*>& commands,
      (metadataGetMode || !torrentAttrs->privateTorrent)) {
     if(!btReg->getLpdMessageReceiver()) {
       A2_LOG_INFO("Initializing LpdMessageReceiver.");
-      SharedHandle<LpdMessageReceiver> receiver
+      std::shared_ptr<LpdMessageReceiver> receiver
         (new LpdMessageReceiver(LPD_MULTICAST_ADDR, LPD_MULTICAST_PORT));
       bool initialized = false;
       const std::string& lpdInterface =
@@ -263,7 +263,7 @@ void BtSetup::setup(std::vector<Command*>& commands,
       const unsigned char* infoHash =
         bittorrent::getInfoHash(requestGroup->getDownloadContext());
       A2_LOG_INFO("Initializing LpdMessageDispatcher.");
-      SharedHandle<LpdMessageDispatcher> dispatcher
+      std::shared_ptr<LpdMessageDispatcher> dispatcher
         (new LpdMessageDispatcher
          (std::string(&infoHash[0], &infoHash[INFO_HASH_LENGTH]),
           btReg->getTcpPort(),
diff --git a/src/BtStopDownloadCommand.h b/src/BtStopDownloadCommand.h
index 156ded76..b0dec361 100644
--- a/src/BtStopDownloadCommand.h
+++ b/src/BtStopDownloadCommand.h
@@ -36,7 +36,8 @@
 #define D_BT_STOP_DOWNLOAD_COMMAND_H
 
 #include "TimeBasedCommand.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -54,9 +55,9 @@ private:
 
   Timer checkPoint_;
 
-  SharedHandle<BtRuntime> btRuntime_;
+  std::shared_ptr<BtRuntime> btRuntime_;
 
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
 public:
   BtStopDownloadCommand
   (cuid_t cuid,
@@ -68,12 +69,12 @@ public:
 
   virtual void process();
 
-  void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime)
+  void setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime)
   {
     btRuntime_ = btRuntime;
   }
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage)
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage)
   {
     pieceStorage_ = pieceStorage;
   }
diff --git a/src/BtUnchokeMessage.cc b/src/BtUnchokeMessage.cc
index 9dfd4a8e..36bda089 100644
--- a/src/BtUnchokeMessage.cc
+++ b/src/BtUnchokeMessage.cc
@@ -63,7 +63,7 @@ bool BtUnchokeMessage::sendPredicate() const
 
 namespace {
 struct ThisProgressUpdate : public ProgressUpdate {
-  ThisProgressUpdate(const SharedHandle<Peer>& peer)
+  ThisProgressUpdate(const std::shared_ptr<Peer>& peer)
     : peer(peer) {}
   virtual void update(size_t length, bool complete)
   {
@@ -71,7 +71,7 @@ struct ThisProgressUpdate : public ProgressUpdate {
       peer->amChoking(false);
     }
   }
-  SharedHandle<Peer> peer;
+  std::shared_ptr<Peer> peer;
 };
 } // namespace
 
diff --git a/src/CheckIntegrityCommand.cc b/src/CheckIntegrityCommand.cc
index c4284211..e2472496 100644
--- a/src/CheckIntegrityCommand.cc
+++ b/src/CheckIntegrityCommand.cc
@@ -50,7 +50,7 @@ namespace aria2 {
 
 CheckIntegrityCommand::CheckIntegrityCommand
 (cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e,
- const SharedHandle<CheckIntegrityEntry>& entry):
+ const std::shared_ptr<CheckIntegrityEntry>& entry):
   RealtimeCommand(cuid, requestGroup, e),
   entry_(entry)
 {}
diff --git a/src/CheckIntegrityCommand.h b/src/CheckIntegrityCommand.h
index 6dce2ce2..3160d8d4 100644
--- a/src/CheckIntegrityCommand.h
+++ b/src/CheckIntegrityCommand.h
@@ -36,7 +36,8 @@
 #define D_CHECK_INTEGRITY_COMMAND_H
 
 #include "RealtimeCommand.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -44,12 +45,12 @@ class CheckIntegrityEntry;
 
 class CheckIntegrityCommand : public RealtimeCommand {
 private:
-  SharedHandle<CheckIntegrityEntry> entry_;
+  std::shared_ptr<CheckIntegrityEntry> entry_;
 public:
   CheckIntegrityCommand(cuid_t cuid,
                         RequestGroup* requestGroup,
                         DownloadEngine* e,
-                        const SharedHandle<CheckIntegrityEntry>& entry);
+                        const std::shared_ptr<CheckIntegrityEntry>& entry);
 
   virtual ~CheckIntegrityCommand();
 
diff --git a/src/CheckIntegrityDispatcherCommand.cc b/src/CheckIntegrityDispatcherCommand.cc
index 49fa965e..ed176cf6 100644
--- a/src/CheckIntegrityDispatcherCommand.cc
+++ b/src/CheckIntegrityDispatcherCommand.cc
@@ -45,7 +45,7 @@ namespace aria2 {
 
 CheckIntegrityDispatcherCommand::CheckIntegrityDispatcherCommand
 (cuid_t cuid,
- const SharedHandle<CheckIntegrityMan>& fileAllocMan,
+ const std::shared_ptr<CheckIntegrityMan>& fileAllocMan,
  DownloadEngine* e)
   : SequentialDispatcherCommand<CheckIntegrityEntry>(cuid, fileAllocMan, e)
 {
@@ -53,7 +53,7 @@ CheckIntegrityDispatcherCommand::CheckIntegrityDispatcherCommand
 }
 
 Command* CheckIntegrityDispatcherCommand::createCommand
-(const SharedHandle<CheckIntegrityEntry>& entry)
+(const std::shared_ptr<CheckIntegrityEntry>& entry)
 {
   cuid_t newCUID = getDownloadEngine()->newCUID();
   A2_LOG_INFO(fmt("CUID#%" PRId64 " - Dispatching CheckIntegrityCommand CUID#%" PRId64 ".",
diff --git a/src/CheckIntegrityDispatcherCommand.h b/src/CheckIntegrityDispatcherCommand.h
index b491909c..4072bba1 100644
--- a/src/CheckIntegrityDispatcherCommand.h
+++ b/src/CheckIntegrityDispatcherCommand.h
@@ -47,11 +47,11 @@ class CheckIntegrityDispatcherCommand :
 public:
   CheckIntegrityDispatcherCommand
   (cuid_t cuid,
-   const SharedHandle<CheckIntegrityMan>& checkMan,
+   const std::shared_ptr<CheckIntegrityMan>& checkMan,
    DownloadEngine* e);
 protected:
   virtual Command* createCommand
-  (const SharedHandle<CheckIntegrityEntry>& entry);
+  (const std::shared_ptr<CheckIntegrityEntry>& entry);
 };
 
 } // namespace aria2
diff --git a/src/CheckIntegrityEntry.cc b/src/CheckIntegrityEntry.cc
index 3430fedb..57252118 100644
--- a/src/CheckIntegrityEntry.cc
+++ b/src/CheckIntegrityEntry.cc
@@ -86,7 +86,7 @@ void CheckIntegrityEntry::cutTrailingGarbage()
 
 void CheckIntegrityEntry::proceedFileAllocation
 (std::vector<Command*>& commands,
- const SharedHandle<FileAllocationEntry>& entry,
+ const std::shared_ptr<FileAllocationEntry>& entry,
  DownloadEngine* e)
 {
   if(getRequestGroup()->needsFileAllocation()) {
@@ -97,7 +97,7 @@ void CheckIntegrityEntry::proceedFileAllocation
 }
 
 void CheckIntegrityEntry::setValidator
-(const SharedHandle<IteratableValidator>& validator)
+(const std::shared_ptr<IteratableValidator>& validator)
 {
   validator_ = validator;
 }
diff --git a/src/CheckIntegrityEntry.h b/src/CheckIntegrityEntry.h
index 64fe0506..dc60bfbc 100644
--- a/src/CheckIntegrityEntry.h
+++ b/src/CheckIntegrityEntry.h
@@ -38,8 +38,8 @@
 #include "RequestGroupEntry.h"
 
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "ProgressAwareEntry.h"
 
 namespace aria2 {
@@ -51,12 +51,12 @@ class FileAllocationEntry;
 class CheckIntegrityEntry : public RequestGroupEntry,
                             public ProgressAwareEntry {
 private:
-  SharedHandle<IteratableValidator> validator_;
+  std::shared_ptr<IteratableValidator> validator_;
 protected:
-  void setValidator(const SharedHandle<IteratableValidator>& validator);
+  void setValidator(const std::shared_ptr<IteratableValidator>& validator);
 
   void proceedFileAllocation(std::vector<Command*>& commands,
-                             const SharedHandle<FileAllocationEntry>& entry,
+                             const std::shared_ptr<FileAllocationEntry>& entry,
                              DownloadEngine* e);
 public:
   CheckIntegrityEntry(RequestGroup* requestGroup, Command* nextCommand = 0);
diff --git a/src/ChecksumCheckIntegrityEntry.cc b/src/ChecksumCheckIntegrityEntry.cc
index b02ae884..34e72635 100644
--- a/src/ChecksumCheckIntegrityEntry.cc
+++ b/src/ChecksumCheckIntegrityEntry.cc
@@ -52,14 +52,14 @@ ChecksumCheckIntegrityEntry::~ChecksumCheckIntegrityEntry() {}
 
 bool ChecksumCheckIntegrityEntry::isValidationReady()
 {
-  const SharedHandle<DownloadContext>& dctx =
+  const std::shared_ptr<DownloadContext>& dctx =
     getRequestGroup()->getDownloadContext();
   return dctx->isChecksumVerificationAvailable();
 }
 
 void ChecksumCheckIntegrityEntry::initValidator()
 {
-  SharedHandle<IteratableChecksumValidator> validator
+  std::shared_ptr<IteratableChecksumValidator> validator
     (new IteratableChecksumValidator(getRequestGroup()->getDownloadContext(),
                                      getRequestGroup()->getPieceStorage()));
   validator->init();
@@ -76,7 +76,7 @@ ChecksumCheckIntegrityEntry::onDownloadIncomplete
 (std::vector<Command*>& commands, DownloadEngine* e)
 {
   if(redownload_) {
-    SharedHandle<FileAllocationEntry> entry
+    std::shared_ptr<FileAllocationEntry> entry
       (new StreamFileAllocationEntry(getRequestGroup(), popNextCommand()));
     proceedFileAllocation(commands, entry, e);
   }
diff --git a/src/ChunkChecksum.h b/src/ChunkChecksum.h
index 965840d1..f1c0580c 100644
--- a/src/ChunkChecksum.h
+++ b/src/ChunkChecksum.h
@@ -40,8 +40,6 @@
 #include <string>
 #include <vector>
 
-#include "SharedHandle.h"
-
 namespace aria2 {
 
 class ChunkChecksum {
diff --git a/src/ChunkedDecodingStreamFilter.cc b/src/ChunkedDecodingStreamFilter.cc
index 21b8502b..94334c1d 100644
--- a/src/ChunkedDecodingStreamFilter.cc
+++ b/src/ChunkedDecodingStreamFilter.cc
@@ -65,7 +65,7 @@ enum {
 } // namespace
 
 ChunkedDecodingStreamFilter::ChunkedDecodingStreamFilter
-(const SharedHandle<StreamFilter>& delegate):
+(const std::shared_ptr<StreamFilter>& delegate):
   StreamFilter(delegate),
   state_(PREV_CHUNK_SIZE),
   chunkSize_(0),
@@ -77,8 +77,8 @@ ChunkedDecodingStreamFilter::~ChunkedDecodingStreamFilter() {}
 void ChunkedDecodingStreamFilter::init() {}
 
 ssize_t ChunkedDecodingStreamFilter::transform
-(const SharedHandle<BinaryStream>& out,
- const SharedHandle<Segment>& segment,
+(const std::shared_ptr<BinaryStream>& out,
+ const std::shared_ptr<Segment>& segment,
  const unsigned char* inbuf, size_t inlen)
 {
   ssize_t outlen = 0;
diff --git a/src/ChunkedDecodingStreamFilter.h b/src/ChunkedDecodingStreamFilter.h
index 8aced1b3..9d0536f0 100644
--- a/src/ChunkedDecodingStreamFilter.h
+++ b/src/ChunkedDecodingStreamFilter.h
@@ -47,15 +47,15 @@ private:
   size_t bytesProcessed_;
 public:
   ChunkedDecodingStreamFilter
-  (const SharedHandle<StreamFilter>& delegate = SharedHandle<StreamFilter>());
+  (const std::shared_ptr<StreamFilter>& delegate = std::shared_ptr<StreamFilter>());
 
   virtual ~ChunkedDecodingStreamFilter();
 
   virtual void init();
 
   virtual ssize_t transform
-  (const SharedHandle<BinaryStream>& out,
-   const SharedHandle<Segment>& segment,
+  (const std::shared_ptr<BinaryStream>& out,
+   const std::shared_ptr<Segment>& segment,
    const unsigned char* inbuf, size_t inlen);
 
   virtual bool finished();
diff --git a/src/ConnectCommand.cc b/src/ConnectCommand.cc
index cb075976..4bb6a33a 100644
--- a/src/ConnectCommand.cc
+++ b/src/ConnectCommand.cc
@@ -48,12 +48,12 @@
 namespace aria2 {
 
 ConnectCommand::ConnectCommand(cuid_t cuid,
-                               const SharedHandle<Request>& req,
-                               const SharedHandle<Request>& proxyRequest,
-                               const SharedHandle<FileEntry>& fileEntry,
+                               const std::shared_ptr<Request>& req,
+                               const std::shared_ptr<Request>& proxyRequest,
+                               const std::shared_ptr<FileEntry>& fileEntry,
                                RequestGroup* requestGroup,
                                DownloadEngine* e,
-                               const SharedHandle<SocketCore>& s)
+                               const std::shared_ptr<SocketCore>& s)
   : AbstractCommand(cuid, req, fileEntry, requestGroup, e, s),
     proxyRequest_(proxyRequest)
 {
@@ -70,18 +70,18 @@ ConnectCommand::~ConnectCommand()
 }
 
 void ConnectCommand::setControlChain
-(const SharedHandle<ControlChain<ConnectCommand*> >& chain)
+(const std::shared_ptr<ControlChain<ConnectCommand*> >& chain)
 {
   chain_ = chain;
 }
 
 void ConnectCommand::setBackupConnectInfo
-(const SharedHandle<BackupConnectInfo>& info)
+(const std::shared_ptr<BackupConnectInfo>& info)
 {
   backupConnectionInfo_ = info;
 }
 
-const SharedHandle<Request>& ConnectCommand::getProxyRequest() const
+const std::shared_ptr<Request>& ConnectCommand::getProxyRequest() const
 {
   return proxyRequest_;
 }
@@ -89,7 +89,7 @@ const SharedHandle<Request>& ConnectCommand::getProxyRequest() const
 bool ConnectCommand::executeInternal()
 {
   if(backupConnectionInfo_ && !backupConnectionInfo_->ipaddr.empty()) {
-    A2_LOG_INFO(fmt("CUID#%"PRId64" - Use backup connection address %s",
+    A2_LOG_INFO(fmt("CUID#%" PRId64 " - Use backup connection address %s",
                     getCuid(), backupConnectionInfo_->ipaddr.c_str()));
     getDownloadEngine()->markBadIPAddress
       (getRequest()->getConnectedHostname(),
diff --git a/src/ConnectCommand.h b/src/ConnectCommand.h
index 1f458ead..003f9b07 100644
--- a/src/ConnectCommand.h
+++ b/src/ConnectCommand.h
@@ -45,24 +45,24 @@ class BackupConnectInfo;
 class ConnectCommand : public AbstractCommand {
 public:
   ConnectCommand(cuid_t cuid,
-                 const SharedHandle<Request>& req,
-                 const SharedHandle<Request>& proxyRequest,
-                 const SharedHandle<FileEntry>& fileEntry,
+                 const std::shared_ptr<Request>& req,
+                 const std::shared_ptr<Request>& proxyRequest,
+                 const std::shared_ptr<FileEntry>& fileEntry,
                  RequestGroup* requestGroup,
                  DownloadEngine* e,
-                 const SharedHandle<SocketCore>& s);
+                 const std::shared_ptr<SocketCore>& s);
   virtual ~ConnectCommand();
   void setControlChain
-  (const SharedHandle<ControlChain<ConnectCommand*> >& chain);
-  void setBackupConnectInfo(const SharedHandle<BackupConnectInfo>& info);
-  const SharedHandle<Request>& getProxyRequest() const;
+  (const std::shared_ptr<ControlChain<ConnectCommand*> >& chain);
+  void setBackupConnectInfo(const std::shared_ptr<BackupConnectInfo>& info);
+  const std::shared_ptr<Request>& getProxyRequest() const;
 protected:
   virtual bool executeInternal();
   virtual bool noCheck();
 private:
-  SharedHandle<Request> proxyRequest_;
-  SharedHandle<BackupConnectInfo> backupConnectionInfo_;
-  SharedHandle<ControlChain<ConnectCommand*> > chain_;
+  std::shared_ptr<Request> proxyRequest_;
+  std::shared_ptr<BackupConnectInfo> backupConnectionInfo_;
+  std::shared_ptr<ControlChain<ConnectCommand*> > chain_;
 };
 
 } // namespace aria2
diff --git a/src/ConsoleStatCalc.cc b/src/ConsoleStatCalc.cc
index 5aa75046..b91e5410 100644
--- a/src/ConsoleStatCalc.cc
+++ b/src/ConsoleStatCalc.cc
@@ -96,7 +96,7 @@ protected:
 } // namespace
 
 namespace {
-void printSizeProgress(std::ostream& o, const SharedHandle<RequestGroup>& rg,
+void printSizeProgress(std::ostream& o, const std::shared_ptr<RequestGroup>& rg,
                        const TransferStat& stat,
                        const SizeFormatter& sizeFormatter)
 {
@@ -144,7 +144,7 @@ void printProgressCompact(std::ostream& o, const DownloadEngine* e,
   const size_t MAX_ITEM = 5;
   for(RequestGroupList::const_iterator i = groups.begin(),
         eoi = groups.end(); i != eoi && cnt < MAX_ITEM; ++i, ++cnt) {
-    const SharedHandle<RequestGroup>& rg = *i;
+    const std::shared_ptr<RequestGroup>& rg = *i;
     TransferStat stat = rg->calculateStat();
     o << "[#" << GroupId::toAbbrevHex(rg->getGID()) << " ";
     printSizeProgress(o, rg, stat, sizeFormatter);
@@ -158,7 +158,7 @@ void printProgressCompact(std::ostream& o, const DownloadEngine* e,
 
 namespace {
 void printProgress
-(std::ostream& o, const SharedHandle<RequestGroup>& rg, const DownloadEngine* e,
+(std::ostream& o, const std::shared_ptr<RequestGroup>& rg, const DownloadEngine* e,
  const SizeFormatter& sizeFormatter)
 {
   TransferStat stat = rg->calculateStat();
@@ -171,7 +171,7 @@ void printProgress
   o << " CN:"
     << rg->getNumConnection();
 #ifdef ENABLE_BITTORRENT
-  const SharedHandle<BtObject>& btObj = e->getBtRegistry()->get(rg->getGID());
+  const std::shared_ptr<BtObject>& btObj = e->getBtRegistry()->get(rg->getGID());
   if(btObj) {
     const PeerSet& peers = btObj->peerStorage->getUsedPeers();
     o << " SD:"
@@ -214,7 +214,7 @@ public:
     const char SEP_CHAR = '-';
     std::stringstream o;
     printProgress(o, rg, e_, sizeFormatter_);
-    const std::vector<SharedHandle<FileEntry> >& fileEntries =
+    const std::vector<std::shared_ptr<FileEntry> >& fileEntries =
       rg->getDownloadContext()->getFileEntries();
     o << "\nFILE: ";
     writeFilePath(fileEntries.begin(), fileEntries.end(),
@@ -321,7 +321,7 @@ ConsoleStatCalc::calculateStat(const DownloadEngine* e)
   }
   size_t numGroup = e->getRequestGroupMan()->countRequestGroup();
   if(numGroup == 1) {
-    const SharedHandle<RequestGroup>& rg =
+    const std::shared_ptr<RequestGroup>& rg =
       *e->getRequestGroupMan()->getRequestGroups().begin();
     printProgress(o, rg, e, sizeFormatter);
   } else if(numGroup > 1) {
@@ -330,7 +330,7 @@ ConsoleStatCalc::calculateStat(const DownloadEngine* e)
   }
 
   {
-    const SharedHandle<FileAllocationEntry>& entry =
+    const std::shared_ptr<FileAllocationEntry>& entry =
       e->getFileAllocationMan()->getPickedEntry();
     if(entry) {
       o << " [FileAlloc:#"
@@ -350,7 +350,7 @@ ConsoleStatCalc::calculateStat(const DownloadEngine* e)
   }
 #ifdef ENABLE_MESSAGE_DIGEST
   {
-    const SharedHandle<CheckIntegrityEntry>& entry =
+    const std::shared_ptr<CheckIntegrityEntry>& entry =
       e->getCheckIntegrityMan()->getPickedEntry();
     if(entry) {
       o << " [Checksum:#"
diff --git a/src/ConsoleStatCalc.h b/src/ConsoleStatCalc.h
index f680ac5f..d9385054 100644
--- a/src/ConsoleStatCalc.h
+++ b/src/ConsoleStatCalc.h
@@ -39,6 +39,7 @@
 
 #include <string>
 #include <functional>
+#include <memory>
 
 #include "TimerA2.h"
 
@@ -62,7 +63,7 @@ private:
 
   time_t summaryInterval_;
 
-  SharedHandle<SizeFormatter> sizeFormatter_;
+  std::shared_ptr<SizeFormatter> sizeFormatter_;
   bool readoutVisibility_;
   bool truncate_;
   bool isTTY_;
diff --git a/src/Context.cc b/src/Context.cc
index ad6b1af1..58f166f2 100644
--- a/src/Context.cc
+++ b/src/Context.cc
@@ -41,7 +41,6 @@
 #include <vector>
 #include <iostream>
 
-#include "SharedHandle.h"
 #include "LogFactory.h"
 #include "Logger.h"
 #include "util.h"
@@ -86,13 +85,13 @@ extern int optind, opterr, optopt;
 
 namespace aria2 {
 
-SharedHandle<StatCalc> getStatCalc(const SharedHandle<Option>& op)
+std::shared_ptr<StatCalc> getStatCalc(const std::shared_ptr<Option>& op)
 {
-  SharedHandle<StatCalc> statCalc;
+  std::shared_ptr<StatCalc> statCalc;
   if(op->getAsBool(PREF_QUIET)) {
     statCalc.reset(new NullStatCalc());
   } else {
-    SharedHandle<ConsoleStatCalc> impl
+    std::shared_ptr<ConsoleStatCalc> impl
       (new ConsoleStatCalc(op->getAsInt(PREF_SUMMARY_INTERVAL),
                            op->getAsBool(PREF_HUMAN_READABLE)));
     impl->setReadoutVisibility(op->getAsBool(PREF_SHOW_CONSOLE_READOUT));
@@ -102,10 +101,10 @@ SharedHandle<StatCalc> getStatCalc(const SharedHandle<Option>& op)
   return statCalc;
 }
 
-SharedHandle<OutputFile> getSummaryOut(const SharedHandle<Option>& op)
+std::shared_ptr<OutputFile> getSummaryOut(const std::shared_ptr<Option>& op)
 {
   if(op->getAsBool(PREF_QUIET)) {
-    return SharedHandle<OutputFile>(new NullOutputFile());
+    return std::shared_ptr<OutputFile>(new NullOutputFile());
   } else {
     return global::cout();
   }
@@ -115,8 +114,8 @@ SharedHandle<OutputFile> getSummaryOut(const SharedHandle<Option>& op)
 namespace {
 void showTorrentFile(const std::string& uri)
 {
-  SharedHandle<Option> op(new Option());
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<Option> op(new Option());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   bittorrent::load(uri, dctx, op);
   bittorrent::print(*global::cout(), dctx);
 }
@@ -126,12 +125,12 @@ void showTorrentFile(const std::string& uri)
 #ifdef ENABLE_METALINK
 namespace {
 void showMetalinkFile
-(const std::string& uri, const SharedHandle<Option>& op)
+(const std::string& uri, const std::shared_ptr<Option>& op)
 {
-  std::vector<SharedHandle<MetalinkEntry> > metalinkEntries;
+  std::vector<std::shared_ptr<MetalinkEntry> > metalinkEntries;
   metalink::parseAndQuery(metalinkEntries, uri, op.get(),
                           op->get(PREF_METALINK_BASE_URI));
-  std::vector<SharedHandle<FileEntry> > fileEntries;
+  std::vector<std::shared_ptr<FileEntry> > fileEntries;
   MetalinkEntry::toFileEntry(fileEntries, metalinkEntries);
   util::toStream(fileEntries.begin(), fileEntries.end(), *global::cout());
   global::cout()->write("\n");
@@ -143,7 +142,7 @@ void showMetalinkFile
 #if defined ENABLE_BITTORRENT || defined ENABLE_METALINK
 namespace {
 void showFiles
-(const std::vector<std::string>& uris, const SharedHandle<Option>& op)
+(const std::vector<std::string>& uris, const std::shared_ptr<Option>& op)
 {
   ProtocolDetector dt;
   for(std::vector<std::string>::const_iterator i = uris.begin(),
@@ -183,7 +182,7 @@ Context::Context(bool standalone,
                  int argc, char** argv, const KeyVals& options)
 {
   std::vector<std::string> args;
-  SharedHandle<Option> op(new Option());
+  std::shared_ptr<Option> op(new Option());
   error_code::Value rv;
   rv = option_processing(*op.get(), standalone, args, argc, argv, options);
   if(rv != error_code::FINISHED) {
@@ -222,8 +221,8 @@ Context::Context(bool standalone,
     std::string iface = op->get(PREF_INTERFACE);
     SocketCore::bindAddress(iface);
   }
-  std::vector<SharedHandle<RequestGroup> > requestGroups;
-  SharedHandle<UriListParser> uriListParser;
+  std::vector<std::shared_ptr<RequestGroup> > requestGroups;
+  std::shared_ptr<UriListParser> uriListParser;
 #ifdef ENABLE_BITTORRENT
   if(!op->blank(PREF_TORRENT_FILE)) {
     if(op->get(PREF_SHOW_FILES) == A2_V_TRUE) {
@@ -266,7 +265,7 @@ Context::Context(bool standalone,
   // command-line. If they are left, because op is used as a template
   // for new RequestGroup(such as created in RPC command), they causes
   // unintentional effect.
-  for(SharedHandle<Option> i = op; i; i = i->getParent()) {
+  for(std::shared_ptr<Option> i = op; i; i = i->getParent()) {
     i->remove(PREF_OUT);
     i->remove(PREF_FORCE_SEQUENTIAL);
     i->remove(PREF_INPUT_FILE);
diff --git a/src/Context.h b/src/Context.h
index 061c9969..3389590f 100644
--- a/src/Context.h
+++ b/src/Context.h
@@ -36,8 +36,10 @@
 #define CONTEXT_H
 
 #include "common.h"
+
+#include <memory>
+
 #include <aria2/aria2.h>
-#include "SharedHandle.h"
 
 namespace aria2 {
 
@@ -51,7 +53,7 @@ struct Context {
   // as a part of command-line arguments.
   Context(bool standalone, int argc, char** argv, const KeyVals& options);
   ~Context();
-  SharedHandle<MultiUrlRequestInfo> reqinfo;
+  std::shared_ptr<MultiUrlRequestInfo> reqinfo;
 };
 
 } // namespace aria2
diff --git a/src/CookieStorage.cc b/src/CookieStorage.cc
index e6a22628..f5819299 100644
--- a/src/CookieStorage.cc
+++ b/src/CookieStorage.cc
@@ -192,7 +192,7 @@ const double DOMAIN_EVICTION_RATE = 0.1;
 bool CookieStorage::store(const Cookie& cookie, time_t now)
 {
   if(domains_.size() >= DOMAIN_EVICTION_TRIGGER) {
-    std::vector<SharedHandle<DomainEntry> > evictions(domains_.begin(),
+    std::vector<std::shared_ptr<DomainEntry> > evictions(domains_.begin(),
                                                       domains_.end());
     std::sort(evictions.begin(), evictions.end(),
               LeastRecentAccess<DomainEntry>());
@@ -200,7 +200,7 @@ bool CookieStorage::store(const Cookie& cookie, time_t now)
     domains_.clear();
     domains_.insert(evictions.begin()+delnum, evictions.end());
   }
-  SharedHandle<DomainEntry> v(new DomainEntry(cookie.getDomain()));
+  std::shared_ptr<DomainEntry> v(new DomainEntry(cookie.getDomain()));
   DomainEntrySet::iterator i = domains_.lower_bound(v);
   bool added = false;
   if(i != domains_.end() && *(*i) == *v) {
@@ -292,7 +292,7 @@ void CookieStorage::searchCookieByDomainSuffix
  const std::string& requestPath,
  time_t now, bool secure)
 {
-  SharedHandle<DomainEntry> v(new DomainEntry(domain));
+  std::shared_ptr<DomainEntry> v(new DomainEntry(domain));
   DomainEntrySet::iterator i = domains_.lower_bound(v);
   if(i != domains_.end() && *(*i) == *v) {
     (*i)->setLastAccessTime(now);
@@ -302,7 +302,7 @@ void CookieStorage::searchCookieByDomainSuffix
 
 bool CookieStorage::contains(const Cookie& cookie) const
 {
-  SharedHandle<DomainEntry> v(new DomainEntry(cookie.getDomain()));
+  std::shared_ptr<DomainEntry> v(new DomainEntry(cookie.getDomain()));
   DomainEntrySet::iterator i = domains_.find(v);
   if(i != domains_.end()) {
     return (*i)->contains(cookie);
diff --git a/src/CookieStorage.h b/src/CookieStorage.h
index 9febfad2..530e0d62 100644
--- a/src/CookieStorage.h
+++ b/src/CookieStorage.h
@@ -114,8 +114,8 @@ public:
     bool operator<(const DomainEntry& de) const;
   };
 private:
-  typedef std::set<SharedHandle<DomainEntry>,
-                   DerefLess<SharedHandle<DomainEntry> > > DomainEntrySet;
+  typedef std::set<std::shared_ptr<DomainEntry>,
+                   DerefLess<std::shared_ptr<DomainEntry> > > DomainEntrySet;
   DomainEntrySet domains_;
 
   template<typename InputIterator>
diff --git a/src/CreateRequestCommand.cc b/src/CreateRequestCommand.cc
index d46936dd..1845af7c 100644
--- a/src/CreateRequestCommand.cc
+++ b/src/CreateRequestCommand.cc
@@ -55,9 +55,9 @@ CreateRequestCommand::CreateRequestCommand(cuid_t cuid,
                                            RequestGroup* requestGroup,
                                            DownloadEngine* e):
   AbstractCommand
-  (cuid, SharedHandle<Request>(), SharedHandle<FileEntry>(), requestGroup, e,
-   SharedHandle<SocketCore>(),
-   SharedHandle<SocketRecvBuffer>(),
+  (cuid, std::shared_ptr<Request>(), std::shared_ptr<FileEntry>(), requestGroup, e,
+   std::shared_ptr<SocketCore>(),
+   std::shared_ptr<SocketRecvBuffer>(),
    false)
 {
   setStatus(Command::STATUS_ONESHOT_REALTIME);
diff --git a/src/DHTAbstractMessage.cc b/src/DHTAbstractMessage.cc
index 518c7e68..146fefac 100644
--- a/src/DHTAbstractMessage.cc
+++ b/src/DHTAbstractMessage.cc
@@ -46,8 +46,8 @@
 
 namespace aria2 {
 
-DHTAbstractMessage::DHTAbstractMessage(const SharedHandle<DHTNode>& localNode,
-                                       const SharedHandle<DHTNode>& remoteNode,
+DHTAbstractMessage::DHTAbstractMessage(const std::shared_ptr<DHTNode>& localNode,
+                                       const std::shared_ptr<DHTNode>& remoteNode,
                                        const std::string& transactionID):
   DHTMessage(localNode, remoteNode, transactionID),
   connection_(0),
diff --git a/src/DHTAbstractMessage.h b/src/DHTAbstractMessage.h
index 33f098fc..b0d7337c 100644
--- a/src/DHTAbstractMessage.h
+++ b/src/DHTAbstractMessage.h
@@ -56,8 +56,8 @@ private:
 
   DHTRoutingTable* routingTable_;
 public:
-  DHTAbstractMessage(const SharedHandle<DHTNode>& localNode,
-                     const SharedHandle<DHTNode>& remoteNode,
+  DHTAbstractMessage(const std::shared_ptr<DHTNode>& localNode,
+                     const std::shared_ptr<DHTNode>& remoteNode,
                      const std::string& transactionID = A2STR::NIL);
 
   virtual ~DHTAbstractMessage();
diff --git a/src/DHTAbstractNodeLookupTask.h b/src/DHTAbstractNodeLookupTask.h
index 75994923..0d7333f3 100644
--- a/src/DHTAbstractNodeLookupTask.h
+++ b/src/DHTAbstractNodeLookupTask.h
@@ -67,31 +67,31 @@ class DHTAbstractNodeLookupTask:public DHTAbstractTask {
 private:
   unsigned char targetID_[DHT_ID_LENGTH];
 
-  std::deque<SharedHandle<DHTNodeLookupEntry> > entries_;
+  std::deque<std::shared_ptr<DHTNodeLookupEntry> > entries_;
 
   size_t inFlightMessage_;
 
   template<typename Container>
   void toEntries
-  (Container& entries, const std::vector<SharedHandle<DHTNode> >& nodes) const
+  (Container& entries, const std::vector<std::shared_ptr<DHTNode> >& nodes) const
   {
-    for(std::vector<SharedHandle<DHTNode> >::const_iterator i = nodes.begin(),
+    for(std::vector<std::shared_ptr<DHTNode> >::const_iterator i = nodes.begin(),
           eoi = nodes.end(); i != eoi; ++i) {
-      SharedHandle<DHTNodeLookupEntry> e(new DHTNodeLookupEntry(*i));
+      std::shared_ptr<DHTNodeLookupEntry> e(new DHTNodeLookupEntry(*i));
       entries.push_back(e);
     }
   }
 
   void sendMessage()
   {
-    for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i =
+    for(std::deque<std::shared_ptr<DHTNodeLookupEntry> >::iterator i =
           entries_.begin(), eoi = entries_.end();
         i != eoi && inFlightMessage_ < ALPHA; ++i) {
       if((*i)->used == false) {
         ++inFlightMessage_;
         (*i)->used = true;
-        SharedHandle<DHTMessage> m = createMessage((*i)->node);
-        SharedHandle<DHTMessageCallback> callback(createCallback());
+        std::shared_ptr<DHTMessage> m = createMessage((*i)->node);
+        std::shared_ptr<DHTMessageCallback> callback(createCallback());
         getMessageDispatcher()->addMessageToQueue(m, callback);
       }
     }
@@ -122,13 +122,13 @@ protected:
     return targetID_;
   }
 
-  const std::deque<SharedHandle<DHTNodeLookupEntry> >& getEntries() const
+  const std::deque<std::shared_ptr<DHTNodeLookupEntry> >& getEntries() const
   {
     return entries_;
   }
 
   virtual void getNodesFromMessage
-  (std::vector<SharedHandle<DHTNode> >& nodes,
+  (std::vector<std::shared_ptr<DHTNode> >& nodes,
    const ResponseMessage* message) = 0;
 
   virtual void onReceivedInternal
@@ -138,10 +138,10 @@ protected:
 
   virtual void onFinish() {}
 
-  virtual SharedHandle<DHTMessage> createMessage
-  (const SharedHandle<DHTNode>& remoteNode) = 0;
+  virtual std::shared_ptr<DHTMessage> createMessage
+  (const std::shared_ptr<DHTNode>& remoteNode) = 0;
 
-  virtual SharedHandle<DHTMessageCallback> createCallback() = 0;
+  virtual std::shared_ptr<DHTMessageCallback> createCallback() = 0;
 public:
   DHTAbstractNodeLookupTask(const unsigned char* targetID):
     inFlightMessage_(0)
@@ -153,7 +153,7 @@ public:
 
   virtual void startup()
   {
-    std::vector<SharedHandle<DHTNode> > nodes;
+    std::vector<std::shared_ptr<DHTNode> > nodes;
     getRoutingTable()->getClosestKNodes(nodes, targetID_);
     entries_.clear();
     toEntries(entries_, nodes);
@@ -174,7 +174,7 @@ public:
   {
     --inFlightMessage_;
     // Replace old Node ID with new Node ID.
-    for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i =
+    for(std::deque<std::shared_ptr<DHTNodeLookupEntry> >::iterator i =
           entries_.begin(), eoi = entries_.end(); i != eoi; ++i) {
       if((*i)->node->getIPAddress() == message->getRemoteNode()->getIPAddress()
          && (*i)->node->getPort() == message->getRemoteNode()->getPort()) {
@@ -182,13 +182,13 @@ public:
       }
     }
     onReceivedInternal(message);
-    std::vector<SharedHandle<DHTNode> > nodes;
+    std::vector<std::shared_ptr<DHTNode> > nodes;
     getNodesFromMessage(nodes, message);
-    std::vector<SharedHandle<DHTNodeLookupEntry> > newEntries;
+    std::vector<std::shared_ptr<DHTNodeLookupEntry> > newEntries;
     toEntries(newEntries, nodes);
 
     size_t count = 0;
-    for(std::vector<SharedHandle<DHTNodeLookupEntry> >::const_iterator i =
+    for(std::vector<std::shared_ptr<DHTNodeLookupEntry> >::const_iterator i =
           newEntries.begin(), eoi = newEntries.end(); i != eoi; ++i) {
       if(memcmp(getLocalNode()->getID(), (*i)->node->getID(),
                 DHT_ID_LENGTH) != 0) {
@@ -205,7 +205,7 @@ public:
     std::stable_sort(entries_.begin(), entries_.end(), DHTIDCloser(targetID_));
     entries_.erase
       (std::unique(entries_.begin(), entries_.end(),
-                   DerefEqualTo<SharedHandle<DHTNodeLookupEntry> >()),
+                   DerefEqualTo<std::shared_ptr<DHTNodeLookupEntry> >()),
        entries_.end());
     A2_LOG_DEBUG(fmt("%lu node lookup entries are unique.",
                      static_cast<unsigned long>(entries_.size())));
@@ -215,12 +215,12 @@ public:
     sendMessageAndCheckFinish();
   }
 
-  void onTimeout(const SharedHandle<DHTNode>& node)
+  void onTimeout(const std::shared_ptr<DHTNode>& node)
   {
     A2_LOG_DEBUG(fmt("node lookup message timeout for node ID=%s",
                      util::toHex(node->getID(), DHT_ID_LENGTH).c_str()));
     --inFlightMessage_;
-    for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i =
+    for(std::deque<std::shared_ptr<DHTNodeLookupEntry> >::iterator i =
           entries_.begin(), eoi = entries_.end(); i != eoi; ++i) {
       if(*(*i)->node == *node) {
         entries_.erase(i);
diff --git a/src/DHTAbstractTask.cc b/src/DHTAbstractTask.cc
index 962f37a4..b7c100fd 100644
--- a/src/DHTAbstractTask.cc
+++ b/src/DHTAbstractTask.cc
@@ -78,7 +78,7 @@ void DHTAbstractTask::setTaskQueue(DHTTaskQueue* taskQueue)
   taskQueue_ = taskQueue;
 }
 
-void DHTAbstractTask::setLocalNode(const SharedHandle<DHTNode>& localNode)
+void DHTAbstractTask::setLocalNode(const std::shared_ptr<DHTNode>& localNode)
 {
   localNode_ = localNode;
 }
diff --git a/src/DHTAbstractTask.h b/src/DHTAbstractTask.h
index 3e20c7bd..65850af7 100644
--- a/src/DHTAbstractTask.h
+++ b/src/DHTAbstractTask.h
@@ -36,7 +36,9 @@
 #define D_DHT_ABSTRACT_TASK_H
 
 #include "DHTTask.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "DHTConstants.h"
 
 namespace aria2 {
@@ -52,7 +54,7 @@ class DHTAbstractTask:public DHTTask {
 private:
   bool finished_;
 
-  SharedHandle<DHTNode> localNode_;
+  std::shared_ptr<DHTNode> localNode_;
 
   DHTRoutingTable* routingTable_;
 
@@ -99,12 +101,12 @@ public:
 
   void setTaskQueue(DHTTaskQueue* taskQueue);
 
-  const SharedHandle<DHTNode>& getLocalNode() const
+  const std::shared_ptr<DHTNode>& getLocalNode() const
   {
     return localNode_;
   }
 
-  void setLocalNode(const SharedHandle<DHTNode>& localNode);
+  void setLocalNode(const std::shared_ptr<DHTNode>& localNode);
 };
 
 } // namespace aria2
diff --git a/src/DHTAnnouncePeerMessage.cc b/src/DHTAnnouncePeerMessage.cc
index 67f48d8e..40f709b2 100644
--- a/src/DHTAnnouncePeerMessage.cc
+++ b/src/DHTAnnouncePeerMessage.cc
@@ -60,8 +60,8 @@ const std::string DHTAnnouncePeerMessage::PORT("port");
 const std::string DHTAnnouncePeerMessage::TOKEN("token");
 
 DHTAnnouncePeerMessage::DHTAnnouncePeerMessage
-(const SharedHandle<DHTNode>& localNode,
- const SharedHandle<DHTNode>& remoteNode,
+(const std::shared_ptr<DHTNode>& localNode,
+ const std::shared_ptr<DHTNode>& remoteNode,
  const unsigned char* infoHash,
  uint16_t tcpPort,
  const std::string& token,
@@ -82,15 +82,15 @@ void DHTAnnouncePeerMessage::doReceivedAction()
   peerAnnounceStorage_->addPeerAnnounce
     (infoHash_, getRemoteNode()->getIPAddress(), tcpPort_);
 
-  SharedHandle<DHTMessage> reply =
+  std::shared_ptr<DHTMessage> reply =
     getMessageFactory()->createAnnouncePeerReplyMessage
     (getRemoteNode(), getTransactionID());
   getMessageDispatcher()->addMessageToQueue(reply);
 }
 
-SharedHandle<Dict> DHTAnnouncePeerMessage::getArgument()
+std::shared_ptr<Dict> DHTAnnouncePeerMessage::getArgument()
 {
-  SharedHandle<Dict> aDict = Dict::g();
+  std::shared_ptr<Dict> aDict = Dict::g();
   aDict->put(DHTMessage::ID, String::g(getLocalNode()->getID(), DHT_ID_LENGTH));
   aDict->put(INFO_HASH, String::g(infoHash_, DHT_ID_LENGTH));
   aDict->put(PORT, Integer::g(tcpPort_));
diff --git a/src/DHTAnnouncePeerMessage.h b/src/DHTAnnouncePeerMessage.h
index b4fc6879..6f1161c9 100644
--- a/src/DHTAnnouncePeerMessage.h
+++ b/src/DHTAnnouncePeerMessage.h
@@ -58,8 +58,8 @@ private:
 protected:
   virtual std::string toStringOptional() const;
 public:
-  DHTAnnouncePeerMessage(const SharedHandle<DHTNode>& localNode,
-                         const SharedHandle<DHTNode>& remoteNode,
+  DHTAnnouncePeerMessage(const std::shared_ptr<DHTNode>& localNode,
+                         const std::shared_ptr<DHTNode>& remoteNode,
                          const unsigned char* infoHash,
                          uint16_t tcpPort,
                          const std::string& token,
@@ -69,7 +69,7 @@ public:
 
   virtual void doReceivedAction();
 
-  virtual SharedHandle<Dict> getArgument();
+  virtual std::shared_ptr<Dict> getArgument();
 
   virtual const std::string& getMessageType() const;
 
diff --git a/src/DHTAnnouncePeerReplyMessage.cc b/src/DHTAnnouncePeerReplyMessage.cc
index 1562d78f..3b094eb5 100644
--- a/src/DHTAnnouncePeerReplyMessage.cc
+++ b/src/DHTAnnouncePeerReplyMessage.cc
@@ -41,8 +41,8 @@ namespace aria2 {
 const std::string DHTAnnouncePeerReplyMessage::ANNOUNCE_PEER("announce_peer");
 
 DHTAnnouncePeerReplyMessage::DHTAnnouncePeerReplyMessage
-(const SharedHandle<DHTNode>& localNode,
- const SharedHandle<DHTNode>& remoteNode,
+(const std::shared_ptr<DHTNode>& localNode,
+ const std::shared_ptr<DHTNode>& remoteNode,
  const std::string& transactionID):
   DHTResponseMessage(localNode, remoteNode, transactionID) {}
 
@@ -50,9 +50,9 @@ DHTAnnouncePeerReplyMessage::~DHTAnnouncePeerReplyMessage() {}
 
 void DHTAnnouncePeerReplyMessage::doReceivedAction() {}
 
-SharedHandle<Dict> DHTAnnouncePeerReplyMessage::getResponse()
+std::shared_ptr<Dict> DHTAnnouncePeerReplyMessage::getResponse()
 {
-  SharedHandle<Dict> rDict = Dict::g();
+  std::shared_ptr<Dict> rDict = Dict::g();
   rDict->put(DHTMessage::ID, String::g(getLocalNode()->getID(), DHT_ID_LENGTH));
   return rDict;
 }
diff --git a/src/DHTAnnouncePeerReplyMessage.h b/src/DHTAnnouncePeerReplyMessage.h
index 0faaae20..1aa323c1 100644
--- a/src/DHTAnnouncePeerReplyMessage.h
+++ b/src/DHTAnnouncePeerReplyMessage.h
@@ -41,15 +41,15 @@ namespace aria2 {
 
 class DHTAnnouncePeerReplyMessage:public DHTResponseMessage {
 public:
-  DHTAnnouncePeerReplyMessage(const SharedHandle<DHTNode>& localNode,
-                              const SharedHandle<DHTNode>& remoteNode,
+  DHTAnnouncePeerReplyMessage(const std::shared_ptr<DHTNode>& localNode,
+                              const std::shared_ptr<DHTNode>& remoteNode,
                               const std::string& transactionID);
 
   virtual ~DHTAnnouncePeerReplyMessage();
 
   virtual void doReceivedAction();
 
-  virtual SharedHandle<Dict> getResponse();
+  virtual std::shared_ptr<Dict> getResponse();
 
   virtual const std::string& getMessageType() const;
 
diff --git a/src/DHTAutoSaveCommand.cc b/src/DHTAutoSaveCommand.cc
index 128b3cfd..05f04e4f 100644
--- a/src/DHTAutoSaveCommand.cc
+++ b/src/DHTAutoSaveCommand.cc
@@ -93,13 +93,13 @@ void DHTAutoSaveCommand::save()
   tempFile.remove();
 
   File(File(dhtFile).getDirname()).mkdirs();
-  std::vector<SharedHandle<DHTNode> > nodes;
-  std::vector<SharedHandle<DHTBucket> > buckets;
+  std::vector<std::shared_ptr<DHTNode> > nodes;
+  std::vector<std::shared_ptr<DHTBucket> > buckets;
   routingTable_->getBuckets(buckets);
-  for(std::vector<SharedHandle<DHTBucket> >::const_iterator i = buckets.begin(),
+  for(std::vector<std::shared_ptr<DHTBucket> >::const_iterator i = buckets.begin(),
         eoi = buckets.end(); i != eoi; ++i) {
-    const SharedHandle<DHTBucket>& bucket = *i;
-    std::vector<SharedHandle<DHTNode> > goodNodes;
+    const std::shared_ptr<DHTBucket>& bucket = *i;
+    std::vector<std::shared_ptr<DHTNode> > goodNodes;
     bucket->getGoodNodes(goodNodes);
     nodes.insert(nodes.end(), goodNodes.begin(), goodNodes.end());
   }
@@ -117,13 +117,13 @@ void DHTAutoSaveCommand::save()
   }
 }
 
-void DHTAutoSaveCommand::setLocalNode(const SharedHandle<DHTNode>& localNode)
+void DHTAutoSaveCommand::setLocalNode(const std::shared_ptr<DHTNode>& localNode)
 {
   localNode_ = localNode;
 }
 
 void DHTAutoSaveCommand::setRoutingTable
-(const SharedHandle<DHTRoutingTable>& routingTable)
+(const std::shared_ptr<DHTRoutingTable>& routingTable)
 {
   routingTable_ = routingTable;
 }
diff --git a/src/DHTAutoSaveCommand.h b/src/DHTAutoSaveCommand.h
index b5663061..dd70040e 100644
--- a/src/DHTAutoSaveCommand.h
+++ b/src/DHTAutoSaveCommand.h
@@ -36,7 +36,8 @@
 #define D_DHT_AUTO_SAVE_COMMAND_H
 
 #include "TimeBasedCommand.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -48,9 +49,9 @@ class DHTAutoSaveCommand : public TimeBasedCommand
 private:
   int family_;
 
-  SharedHandle<DHTNode> localNode_;
+  std::shared_ptr<DHTNode> localNode_;
 
-  SharedHandle<DHTRoutingTable> routingTable_;
+  std::shared_ptr<DHTRoutingTable> routingTable_;
 
   void save();
 public:
@@ -63,9 +64,9 @@ public:
 
   virtual void process();
 
-  void setLocalNode(const SharedHandle<DHTNode>& localNode);
+  void setLocalNode(const std::shared_ptr<DHTNode>& localNode);
 
-  void setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable);
+  void setRoutingTable(const std::shared_ptr<DHTRoutingTable>& routingTable);
 };
 
 } // namespace aria2
diff --git a/src/DHTBucket.cc b/src/DHTBucket.cc
index a84e76a8..16292ea4 100644
--- a/src/DHTBucket.cc
+++ b/src/DHTBucket.cc
@@ -54,7 +54,7 @@ namespace aria2 {
 DHTBucket::DHTBucket
 (size_t prefixLength,
  const unsigned char* max, const unsigned char* min,
- const SharedHandle<DHTNode>& localNode)
+ const std::shared_ptr<DHTNode>& localNode)
   : prefixLength_(prefixLength),
     localNode_(localNode),
     lastUpdated_(global::wallclock())
@@ -63,7 +63,7 @@ DHTBucket::DHTBucket
   memcpy(min_, min, DHT_ID_LENGTH);
 }
 
-DHTBucket::DHTBucket(const SharedHandle<DHTNode>& localNode)
+DHTBucket::DHTBucket(const std::shared_ptr<DHTNode>& localNode)
   : prefixLength_(0),
     localNode_(localNode),
     lastUpdated_(global::wallclock())
@@ -85,7 +85,7 @@ void DHTBucket::getRandomNodeID(unsigned char* nodeID) const
   }
 }
 
-bool DHTBucket::isInRange(const SharedHandle<DHTNode>& node) const
+bool DHTBucket::isInRange(const std::shared_ptr<DHTNode>& node) const
 {
   return isInRange(node->getID(), max_, min_);
 }
@@ -107,10 +107,10 @@ bool DHTBucket::isInRange(const unsigned char* nodeID,
                                   &nodeID[0], &nodeID[DHT_ID_LENGTH]);
 }
 
-bool DHTBucket::addNode(const SharedHandle<DHTNode>& node)
+bool DHTBucket::addNode(const std::shared_ptr<DHTNode>& node)
 {
   notifyUpdate();
-  std::deque<SharedHandle<DHTNode> >::iterator itr =
+  std::deque<std::shared_ptr<DHTNode> >::iterator itr =
     std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
   if(itr == nodes_.end()) {
     if(nodes_.size() < K) {
@@ -132,19 +132,19 @@ bool DHTBucket::addNode(const SharedHandle<DHTNode>& node)
   }
 }
 
-void DHTBucket::cacheNode(const SharedHandle<DHTNode>& node)
+void DHTBucket::cacheNode(const std::shared_ptr<DHTNode>& node)
 {
   // cachedNodes_ are sorted by last time seen
   cachedNodes_.push_front(node);
   if(cachedNodes_.size() > CACHE_SIZE) {
-    cachedNodes_.resize(CACHE_SIZE, SharedHandle<DHTNode>());
+    cachedNodes_.resize(CACHE_SIZE, std::shared_ptr<DHTNode>());
   }
 }
 
-void DHTBucket::dropNode(const SharedHandle<DHTNode>& node)
+void DHTBucket::dropNode(const std::shared_ptr<DHTNode>& node)
 {
   if(!cachedNodes_.empty()) {
-    std::deque<SharedHandle<DHTNode> >::iterator itr =
+    std::deque<std::shared_ptr<DHTNode> >::iterator itr =
       std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
     if(itr != nodes_.end()) {
       nodes_.erase(itr);
@@ -154,9 +154,9 @@ void DHTBucket::dropNode(const SharedHandle<DHTNode>& node)
   }
 }
 
-void DHTBucket::moveToHead(const SharedHandle<DHTNode>& node)
+void DHTBucket::moveToHead(const std::shared_ptr<DHTNode>& node)
 {
-  std::deque<SharedHandle<DHTNode> >::iterator itr =
+  std::deque<std::shared_ptr<DHTNode> >::iterator itr =
     std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
   if(itr != nodes_.end()) {
     nodes_.erase(itr);
@@ -164,9 +164,9 @@ void DHTBucket::moveToHead(const SharedHandle<DHTNode>& node)
   }
 }
 
-void DHTBucket::moveToTail(const SharedHandle<DHTNode>& node)
+void DHTBucket::moveToTail(const std::shared_ptr<DHTNode>& node)
 {
-  std::deque<SharedHandle<DHTNode> >::iterator itr =
+  std::deque<std::shared_ptr<DHTNode> >::iterator itr =
     std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
   if(itr != nodes_.end()) {
     nodes_.erase(itr);
@@ -179,7 +179,7 @@ bool DHTBucket::splitAllowed() const
   return prefixLength_ < DHT_ID_LENGTH*8-1 && isInRange(localNode_);
 }
 
-SharedHandle<DHTBucket> DHTBucket::split()
+std::shared_ptr<DHTBucket> DHTBucket::split()
 {
   assert(splitAllowed());
 
@@ -192,11 +192,11 @@ SharedHandle<DHTBucket> DHTBucket::split()
   bitfield::flipBit(min_, DHT_ID_LENGTH, prefixLength_);
 
   ++prefixLength_;
-  SharedHandle<DHTBucket> rBucket(new DHTBucket(prefixLength_,
+  std::shared_ptr<DHTBucket> rBucket(new DHTBucket(prefixLength_,
                                                 rMax, rMin, localNode_));
 
-  std::deque<SharedHandle<DHTNode> > lNodes;
-  for(std::deque<SharedHandle<DHTNode> >::iterator i = nodes_.begin(),
+  std::deque<std::shared_ptr<DHTNode> > lNodes;
+  for(std::deque<std::shared_ptr<DHTNode> >::iterator i = nodes_.begin(),
         eoi = nodes_.end(); i != eoi; ++i) {
     if(rBucket->isInRange(*i)) {
       assert(rBucket->addNode(*i));
@@ -218,23 +218,23 @@ SharedHandle<DHTBucket> DHTBucket::split()
 }
 
 void DHTBucket::getGoodNodes
-(std::vector<SharedHandle<DHTNode> >& goodNodes) const
+(std::vector<std::shared_ptr<DHTNode> >& goodNodes) const
 {
   goodNodes.insert(goodNodes.end(), nodes_.begin(), nodes_.end());
   goodNodes.erase(std::remove_if(goodNodes.begin(), goodNodes.end(),
                                  mem_fun_sh(&DHTNode::isBad)), goodNodes.end());
 }
 
-SharedHandle<DHTNode> DHTBucket::getNode(const unsigned char* nodeID, const std::string& ipaddr, uint16_t port) const
+std::shared_ptr<DHTNode> DHTBucket::getNode(const unsigned char* nodeID, const std::string& ipaddr, uint16_t port) const
 {
-  SharedHandle<DHTNode> node(new DHTNode(nodeID));
+  std::shared_ptr<DHTNode> node(new DHTNode(nodeID));
   node->setIPAddress(ipaddr);
   node->setPort(port);
-  std::deque<SharedHandle<DHTNode> >::const_iterator itr =
+  std::deque<std::shared_ptr<DHTNode> >::const_iterator itr =
     std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
   if(itr == nodes_.end() ||
      (*itr)->getIPAddress() != ipaddr || (*itr)->getPort() != port) {
-    return SharedHandle<DHTNode>();
+    return std::shared_ptr<DHTNode>();
   } else {
     return *itr;
   }
@@ -260,7 +260,7 @@ void DHTBucket::notifyUpdate()
 namespace {
 class FindQuestionableNode {
 public:
-  bool operator()(const SharedHandle<DHTNode>& node) const
+  bool operator()(const std::shared_ptr<DHTNode>& node) const
   {
     return node->isQuestionable();
   }
@@ -272,12 +272,12 @@ bool DHTBucket::containsQuestionableNode() const
   return std::find_if(nodes_.begin(), nodes_.end(), FindQuestionableNode()) != nodes_.end();
 }
 
-SharedHandle<DHTNode> DHTBucket::getLRUQuestionableNode() const
+std::shared_ptr<DHTNode> DHTBucket::getLRUQuestionableNode() const
 {
-  std::deque<SharedHandle<DHTNode> >::const_iterator i =
+  std::deque<std::shared_ptr<DHTNode> >::const_iterator i =
     std::find_if(nodes_.begin(), nodes_.end(), FindQuestionableNode());
   if(i == nodes_.end()) {
-    return SharedHandle<DHTNode>();
+    return std::shared_ptr<DHTNode>();
   } else {
     return *i;
   }
diff --git a/src/DHTBucket.h b/src/DHTBucket.h
index 6c1d6a5b..3a94ecf4 100644
--- a/src/DHTBucket.h
+++ b/src/DHTBucket.h
@@ -40,8 +40,8 @@
 #include <string>
 #include <deque>
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "DHTConstants.h"
 #include "TimerA2.h"
 
@@ -58,25 +58,25 @@ private:
 
   unsigned char max_[DHT_ID_LENGTH];
 
-  SharedHandle<DHTNode> localNode_;
+  std::shared_ptr<DHTNode> localNode_;
 
   // sorted in ascending order
-  std::deque<SharedHandle<DHTNode> > nodes_;
+  std::deque<std::shared_ptr<DHTNode> > nodes_;
 
   // a replacement cache. The maximum size is specified by CACHE_SIZE.
   // This is sorted by last time seen.
-  std::deque<SharedHandle<DHTNode> > cachedNodes_;
+  std::deque<std::shared_ptr<DHTNode> > cachedNodes_;
 
   Timer lastUpdated_;
 
   bool isInRange(const unsigned char* nodeID,
                  const unsigned char* max, const unsigned char* min) const;
 public:
-  DHTBucket(const SharedHandle<DHTNode>& localNode);
+  DHTBucket(const std::shared_ptr<DHTNode>& localNode);
 
   DHTBucket(size_t prefixLength,
             const unsigned char* max, const unsigned char* min,
-            const SharedHandle<DHTNode>& localNode);
+            const std::shared_ptr<DHTNode>& localNode);
 
   ~DHTBucket();
 
@@ -86,15 +86,15 @@ public:
 
   void getRandomNodeID(unsigned char* nodeID) const;
 
-  SharedHandle<DHTBucket> split();
+  std::shared_ptr<DHTBucket> split();
 
-  bool isInRange(const SharedHandle<DHTNode>& node) const;
+  bool isInRange(const std::shared_ptr<DHTNode>& node) const;
 
   bool isInRange(const unsigned char* nodeID) const;
 
-  bool addNode(const SharedHandle<DHTNode>& node);
+  bool addNode(const std::shared_ptr<DHTNode>& node);
 
-  void cacheNode(const SharedHandle<DHTNode>& node);
+  void cacheNode(const std::shared_ptr<DHTNode>& node);
 
   bool splitAllowed() const;
 
@@ -118,22 +118,22 @@ public:
     return nodes_.size();
   }
 
-  const std::deque<SharedHandle<DHTNode> >& getNodes() const
+  const std::deque<std::shared_ptr<DHTNode> >& getNodes() const
   {
     return nodes_;
   }
 
-  void getGoodNodes(std::vector<SharedHandle<DHTNode> >& nodes) const;
+  void getGoodNodes(std::vector<std::shared_ptr<DHTNode> >& nodes) const;
 
-  void dropNode(const SharedHandle<DHTNode>& node);
+  void dropNode(const std::shared_ptr<DHTNode>& node);
 
-  void moveToHead(const SharedHandle<DHTNode>& node);
+  void moveToHead(const std::shared_ptr<DHTNode>& node);
 
-  void moveToTail(const SharedHandle<DHTNode>& node);
+  void moveToTail(const std::shared_ptr<DHTNode>& node);
 
-  bool contains(const SharedHandle<DHTNode>& node) const;
+  bool contains(const std::shared_ptr<DHTNode>& node) const;
 
-  SharedHandle<DHTNode> getNode(const unsigned char* nodeID, const std::string& ipaddr, uint16_t port) const;
+  std::shared_ptr<DHTNode> getNode(const unsigned char* nodeID, const std::string& ipaddr, uint16_t port) const;
 
   bool operator==(const DHTBucket& bucket) const;
 
@@ -143,9 +143,9 @@ public:
 
   bool containsQuestionableNode() const;
 
-  SharedHandle<DHTNode> getLRUQuestionableNode() const;
+  std::shared_ptr<DHTNode> getLRUQuestionableNode() const;
 
-  const std::deque<SharedHandle<DHTNode> >& getCachedNodes() const
+  const std::deque<std::shared_ptr<DHTNode> >& getCachedNodes() const
   {
     return cachedNodes_;
   }
diff --git a/src/DHTBucketRefreshCommand.cc b/src/DHTBucketRefreshCommand.cc
index aa155b52..e3001f78 100644
--- a/src/DHTBucketRefreshCommand.cc
+++ b/src/DHTBucketRefreshCommand.cc
@@ -62,19 +62,19 @@ void DHTBucketRefreshCommand::process()
 }
 
 void DHTBucketRefreshCommand::setRoutingTable
-(const SharedHandle<DHTRoutingTable>& routingTable)
+(const std::shared_ptr<DHTRoutingTable>& routingTable)
 {
   routingTable_ = routingTable;
 }
 
 void DHTBucketRefreshCommand::setTaskQueue
-(const SharedHandle<DHTTaskQueue>& taskQueue)
+(const std::shared_ptr<DHTTaskQueue>& taskQueue)
 {
   taskQueue_ = taskQueue;
 }
 
 void DHTBucketRefreshCommand::setTaskFactory
-(const SharedHandle<DHTTaskFactory>& taskFactory)
+(const std::shared_ptr<DHTTaskFactory>& taskFactory)
 {
   taskFactory_ = taskFactory;
 }
diff --git a/src/DHTBucketRefreshCommand.h b/src/DHTBucketRefreshCommand.h
index 88d48fa4..d29aff7b 100644
--- a/src/DHTBucketRefreshCommand.h
+++ b/src/DHTBucketRefreshCommand.h
@@ -36,7 +36,8 @@
 #define D_DHT_BUCKET_REFRESH_COMMAND_H
 
 #include "TimeBasedCommand.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -46,11 +47,11 @@ class DHTTaskFactory;
 
 class DHTBucketRefreshCommand:public TimeBasedCommand {
 private:
-  SharedHandle<DHTRoutingTable> routingTable_;
+  std::shared_ptr<DHTRoutingTable> routingTable_;
 
-  SharedHandle<DHTTaskQueue> taskQueue_;
+  std::shared_ptr<DHTTaskQueue> taskQueue_;
 
-  SharedHandle<DHTTaskFactory> taskFactory_;
+  std::shared_ptr<DHTTaskFactory> taskFactory_;
 public:
   DHTBucketRefreshCommand(cuid_t cuid, DownloadEngine* e, time_t interval);
 
@@ -60,11 +61,11 @@ public:
 
   virtual void process();
 
-  void setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable);
+  void setRoutingTable(const std::shared_ptr<DHTRoutingTable>& routingTable);
 
-  void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);
+  void setTaskQueue(const std::shared_ptr<DHTTaskQueue>& taskQueue);
 
-  void setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory);
+  void setTaskFactory(const std::shared_ptr<DHTTaskFactory>& taskFactory);
 };
 
 } // namespace aria2
diff --git a/src/DHTBucketRefreshTask.cc b/src/DHTBucketRefreshTask.cc
index 7b76138c..827693c0 100644
--- a/src/DHTBucketRefreshTask.cc
+++ b/src/DHTBucketRefreshTask.cc
@@ -54,15 +54,15 @@ DHTBucketRefreshTask::~DHTBucketRefreshTask() {}
 
 void DHTBucketRefreshTask::startup()
 {
-  std::vector<SharedHandle<DHTBucket> > buckets;
+  std::vector<std::shared_ptr<DHTBucket> > buckets;
   getRoutingTable()->getBuckets(buckets);
-  for(std::vector<SharedHandle<DHTBucket> >::iterator i = buckets.begin(),
+  for(std::vector<std::shared_ptr<DHTBucket> >::iterator i = buckets.begin(),
         eoi = buckets.end(); i != eoi; ++i) {
     if(forceRefresh_ || (*i)->needsRefresh()) {
       (*i)->notifyUpdate();
       unsigned char targetID[DHT_ID_LENGTH];
       (*i)->getRandomNodeID(targetID);
-      SharedHandle<DHTNodeLookupTask> task(new DHTNodeLookupTask(targetID));
+      std::shared_ptr<DHTNodeLookupTask> task(new DHTNodeLookupTask(targetID));
       task->setRoutingTable(getRoutingTable());
       task->setMessageDispatcher(getMessageDispatcher());
       task->setMessageFactory(getMessageFactory());
diff --git a/src/DHTBucketTree.cc b/src/DHTBucketTree.cc
index 8ea7247f..80deb65b 100644
--- a/src/DHTBucketTree.cc
+++ b/src/DHTBucketTree.cc
@@ -52,7 +52,7 @@ DHTBucketTreeNode::DHTBucketTreeNode
   resetRelation();
 }
 
-DHTBucketTreeNode::DHTBucketTreeNode(const SharedHandle<DHTBucket>& bucket)
+DHTBucketTreeNode::DHTBucketTreeNode(const std::shared_ptr<DHTBucket>& bucket)
   : parent_(0),
     left_(0),
     right_(0),
@@ -99,7 +99,7 @@ bool DHTBucketTreeNode::isInRange(const unsigned char* key) const
 
 void DHTBucketTreeNode::split()
 {
-  SharedHandle<DHTBucket> leftBucket = bucket_->split();
+  std::shared_ptr<DHTBucket> leftBucket = bucket_->split();
   left_ = new DHTBucketTreeNode(leftBucket);
   right_ = new DHTBucketTreeNode(bucket_);
   bucket_.reset();
@@ -118,7 +118,7 @@ DHTBucketTreeNode* findTreeNodeFor
   }
 }
 
-SharedHandle<DHTBucket> findBucketFor
+std::shared_ptr<DHTBucket> findBucketFor
 (DHTBucketTreeNode* root, const unsigned char* key)
 {
   DHTBucketTreeNode* leaf = findTreeNodeFor(root, key);
@@ -127,10 +127,10 @@ SharedHandle<DHTBucket> findBucketFor
 
 namespace {
 void collectNodes
-(std::vector<SharedHandle<DHTNode> >& nodes,
- const SharedHandle<DHTBucket>& bucket)
+(std::vector<std::shared_ptr<DHTNode> >& nodes,
+ const std::shared_ptr<DHTBucket>& bucket)
 {
-  std::vector<SharedHandle<DHTNode> > goodNodes;
+  std::vector<std::shared_ptr<DHTNode> > goodNodes;
   bucket->getGoodNodes(goodNodes);
   nodes.insert(nodes.end(), goodNodes.begin(), goodNodes.end());
 }
@@ -138,7 +138,7 @@ void collectNodes
 
 namespace {
 void collectDownwardLeftFirst
-(std::vector<SharedHandle<DHTNode> >& nodes,  DHTBucketTreeNode* tnode)
+(std::vector<std::shared_ptr<DHTNode> >& nodes,  DHTBucketTreeNode* tnode)
 {
   if(tnode->leaf()) {
     collectNodes(nodes, tnode->getBucket());
@@ -153,7 +153,7 @@ void collectDownwardLeftFirst
 
 namespace {
 void collectDownwardRightFirst
-(std::vector<SharedHandle<DHTNode> >& nodes,  DHTBucketTreeNode* tnode)
+(std::vector<std::shared_ptr<DHTNode> >& nodes,  DHTBucketTreeNode* tnode)
 {
   if(tnode->leaf()) {
     collectNodes(nodes, tnode->getBucket());
@@ -168,7 +168,7 @@ void collectDownwardRightFirst
 
 namespace {
 void collectUpward
-(std::vector<SharedHandle<DHTNode> >& nodes, DHTBucketTreeNode* from)
+(std::vector<std::shared_ptr<DHTNode> >& nodes, DHTBucketTreeNode* from)
 {
   while(1) {
     DHTBucketTreeNode* parent = from->getParent();
@@ -189,7 +189,7 @@ void collectUpward
 } // namespace
 
 void findClosestKNodes
-(std::vector<SharedHandle<DHTNode> >& nodes,
+(std::vector<std::shared_ptr<DHTNode> >& nodes,
  DHTBucketTreeNode* root,
  const unsigned char* key)
 {
@@ -217,7 +217,7 @@ void findClosestKNodes
 }
 
 void enumerateBucket
-(std::vector<SharedHandle<DHTBucket> >& buckets,  DHTBucketTreeNode* root)
+(std::vector<std::shared_ptr<DHTBucket> >& buckets,  DHTBucketTreeNode* root)
 {
   if(root->leaf()) {
     buckets.push_back(root->getBucket());
diff --git a/src/DHTBucketTree.h b/src/DHTBucketTree.h
index 46d32b2c..96059bd5 100644
--- a/src/DHTBucketTree.h
+++ b/src/DHTBucketTree.h
@@ -38,8 +38,8 @@
 #include "common.h"
 
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "DHTConstants.h"
 
 namespace aria2 {
@@ -55,20 +55,20 @@ public:
   // Ctor for internal node
   DHTBucketTreeNode(DHTBucketTreeNode* left, DHTBucketTreeNode* right);
   // Ctor for leaf node
-  DHTBucketTreeNode(const SharedHandle<DHTBucket>& bucket);
+  DHTBucketTreeNode(const std::shared_ptr<DHTBucket>& bucket);
   ~DHTBucketTreeNode();
   // Returns child node, left or right, which contains key.  If dig is
   // called against leaf node, then returns 0.
   DHTBucketTreeNode* dig(const unsigned char* key);
   bool isInRange(const unsigned char* key) const;
   // Returns true iff this is a leaf node.
-  bool leaf() const { return bucket_; }
+  bool leaf() const { return bucket_.get(); }
   const unsigned char* getMaxId() const { return maxId_; }
   const unsigned char* getMinId() const { return minId_; }
   DHTBucketTreeNode* getParent() const { return parent_; }
   DHTBucketTreeNode* getLeft() const { return left_; }
   DHTBucketTreeNode* getRight() const { return right_; }
-  const SharedHandle<DHTBucket>& getBucket() const { return bucket_; }
+  const std::shared_ptr<DHTBucket>& getBucket() const { return bucket_; }
   // Splits this object's bucket using DHTBucket::split() and create
   // left and right child node to hold buckets. The bucket of current
   // node is reseted so this node becomes internal node after this
@@ -85,7 +85,7 @@ private:
   DHTBucketTreeNode* parent_;
   DHTBucketTreeNode* left_;
   DHTBucketTreeNode* right_;
-  SharedHandle<DHTBucket> bucket_;
+  std::shared_ptr<DHTBucket> bucket_;
   unsigned char minId_[DHT_ID_LENGTH];
   unsigned char maxId_[DHT_ID_LENGTH];
 };
@@ -100,7 +100,7 @@ DHTBucketTreeNode* findTreeNodeFor
 // Returns bucket where key fits between bucket's min and max ID
 // range. This function first use findTreeNodeFor and returns its
 // bucket_.
-SharedHandle<DHTBucket> findBucketFor
+std::shared_ptr<DHTBucket> findBucketFor
 (DHTBucketTreeNode* root, const unsigned char* key);
 
 // Stores most closest K nodes against key in nodes. K is
@@ -108,13 +108,13 @@ SharedHandle<DHTBucket> findBucketFor
 // the routing tree contains less than K nodes. The order of nodes is
 // arbitrary.  Caller must pass empty nodes.
 void findClosestKNodes
-(std::vector<SharedHandle<DHTNode> >& nodes,
+(std::vector<std::shared_ptr<DHTNode> >& nodes,
  DHTBucketTreeNode* root,
  const unsigned char* key);
 
 // Stores all buckets in buckets.
 void enumerateBucket
-(std::vector<SharedHandle<DHTBucket> >& buckets, DHTBucketTreeNode* root);
+(std::vector<std::shared_ptr<DHTBucket> >& buckets, DHTBucketTreeNode* root);
 
 } // namespace dht
 
diff --git a/src/DHTConnectionImpl.h b/src/DHTConnectionImpl.h
index 91875e05..8409f053 100644
--- a/src/DHTConnectionImpl.h
+++ b/src/DHTConnectionImpl.h
@@ -36,7 +36,9 @@
 #define D_DHT_CONNECTION_IMPL_H
 
 #include "DHTConnection.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "SegList.h"
 
 namespace aria2 {
@@ -45,7 +47,7 @@ class SocketCore;
 
 class DHTConnectionImpl:public DHTConnection {
 private:
-  SharedHandle<SocketCore> socket_;
+  std::shared_ptr<SocketCore> socket_;
 
   int family_;
 public:
@@ -80,7 +82,7 @@ public:
   virtual ssize_t sendMessage(const unsigned char* data, size_t len,
                               const std::string& host, uint16_t port);
 
-  const SharedHandle<SocketCore>& getSocket() const
+  const std::shared_ptr<SocketCore>& getSocket() const
   {
     return socket_;
   }
diff --git a/src/DHTEntryPointNameResolveCommand.cc b/src/DHTEntryPointNameResolveCommand.cc
index 2df1250f..05e68a11 100644
--- a/src/DHTEntryPointNameResolveCommand.cc
+++ b/src/DHTEntryPointNameResolveCommand.cc
@@ -148,7 +148,7 @@ bool DHTEntryPointNameResolveCommand::execute()
 void DHTEntryPointNameResolveCommand::addPingTask
 (const std::pair<std::string, uint16_t>& addr)
 {
-  SharedHandle<DHTNode> entryNode(new DHTNode());
+  std::shared_ptr<DHTNode> entryNode(new DHTNode());
   entryNode->setIPAddress(addr.first);
   entryNode->setPort(addr.second);
 
@@ -198,25 +198,25 @@ void DHTEntryPointNameResolveCommand::setBootstrapEnabled(bool f)
 }
 
 void DHTEntryPointNameResolveCommand::setTaskQueue
-(const SharedHandle<DHTTaskQueue>& taskQueue)
+(const std::shared_ptr<DHTTaskQueue>& taskQueue)
 {
   taskQueue_ = taskQueue;
 }
 
 void DHTEntryPointNameResolveCommand::setTaskFactory
-(const SharedHandle<DHTTaskFactory>& taskFactory)
+(const std::shared_ptr<DHTTaskFactory>& taskFactory)
 {
   taskFactory_ = taskFactory;
 }
 
 void DHTEntryPointNameResolveCommand::setRoutingTable
-(const SharedHandle<DHTRoutingTable>& routingTable)
+(const std::shared_ptr<DHTRoutingTable>& routingTable)
 {
   routingTable_ = routingTable;
 }
 
 void DHTEntryPointNameResolveCommand::setLocalNode
-(const SharedHandle<DHTNode>& localNode)
+(const std::shared_ptr<DHTNode>& localNode)
 {
   localNode_ = localNode;
 }
diff --git a/src/DHTEntryPointNameResolveCommand.h b/src/DHTEntryPointNameResolveCommand.h
index ea30deff..fde848fc 100644
--- a/src/DHTEntryPointNameResolveCommand.h
+++ b/src/DHTEntryPointNameResolveCommand.h
@@ -41,8 +41,7 @@
 #include <vector>
 #include <deque>
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -60,16 +59,16 @@ private:
   DownloadEngine* e_;
 
 #ifdef ENABLE_ASYNC_DNS
-  SharedHandle<AsyncNameResolverMan> asyncNameResolverMan_;
+  std::shared_ptr<AsyncNameResolverMan> asyncNameResolverMan_;
 #endif // ENABLE_ASYNC_DNS
 
-  SharedHandle<DHTTaskQueue> taskQueue_;
+  std::shared_ptr<DHTTaskQueue> taskQueue_;
 
-  SharedHandle<DHTTaskFactory> taskFactory_;
+  std::shared_ptr<DHTTaskFactory> taskFactory_;
 
-  SharedHandle<DHTRoutingTable> routingTable_;
+  std::shared_ptr<DHTRoutingTable> routingTable_;
 
-  SharedHandle<DHTNode> localNode_;
+  std::shared_ptr<DHTNode> localNode_;
 
   std::deque<std::pair<std::string, uint16_t> > entryPoints_;
 
@@ -95,13 +94,13 @@ public:
 
   void setBootstrapEnabled(bool f);
 
-  void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);
+  void setTaskQueue(const std::shared_ptr<DHTTaskQueue>& taskQueue);
 
-  void setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory);
+  void setTaskFactory(const std::shared_ptr<DHTTaskFactory>& taskFactory);
 
-  void setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable);
+  void setRoutingTable(const std::shared_ptr<DHTRoutingTable>& routingTable);
 
-  void setLocalNode(const SharedHandle<DHTNode>& localNode);
+  void setLocalNode(const std::shared_ptr<DHTNode>& localNode);
 };
 
 } // namespace aria2
diff --git a/src/DHTFindNodeMessage.cc b/src/DHTFindNodeMessage.cc
index ede5f57f..60adb6cd 100644
--- a/src/DHTFindNodeMessage.cc
+++ b/src/DHTFindNodeMessage.cc
@@ -49,8 +49,8 @@ const std::string DHTFindNodeMessage::FIND_NODE("find_node");
 
 const std::string DHTFindNodeMessage::TARGET_NODE("target");
 
-DHTFindNodeMessage::DHTFindNodeMessage(const SharedHandle<DHTNode>& localNode,
-                                       const SharedHandle<DHTNode>& remoteNode,
+DHTFindNodeMessage::DHTFindNodeMessage(const std::shared_ptr<DHTNode>& localNode,
+                                       const std::shared_ptr<DHTNode>& remoteNode,
                                        const unsigned char* targetNodeID,
                                        const std::string& transactionID):
   DHTQueryMessage(localNode, remoteNode, transactionID)
@@ -62,17 +62,17 @@ DHTFindNodeMessage::~DHTFindNodeMessage() {}
 
 void DHTFindNodeMessage::doReceivedAction()
 {
-  std::vector<SharedHandle<DHTNode> > nodes;
+  std::vector<std::shared_ptr<DHTNode> > nodes;
   getRoutingTable()->getClosestKNodes(nodes, targetNodeID_);
-  SharedHandle<DHTMessage> reply =
+  std::shared_ptr<DHTMessage> reply =
     getMessageFactory()->createFindNodeReplyMessage
     (getRemoteNode(), nodes, getTransactionID());
   getMessageDispatcher()->addMessageToQueue(reply);
 }
 
-SharedHandle<Dict> DHTFindNodeMessage::getArgument()
+std::shared_ptr<Dict> DHTFindNodeMessage::getArgument()
 {
-  SharedHandle<Dict> aDict = Dict::g();
+  std::shared_ptr<Dict> aDict = Dict::g();
   aDict->put(DHTMessage::ID, String::g(getLocalNode()->getID(), DHT_ID_LENGTH));
   aDict->put(TARGET_NODE, String::g(targetNodeID_, DHT_ID_LENGTH));
   return aDict;
diff --git a/src/DHTFindNodeMessage.h b/src/DHTFindNodeMessage.h
index 431756f2..05ca99a3 100644
--- a/src/DHTFindNodeMessage.h
+++ b/src/DHTFindNodeMessage.h
@@ -46,8 +46,8 @@ private:
 protected:
   virtual std::string toStringOptional() const;
 public:
-  DHTFindNodeMessage(const SharedHandle<DHTNode>& localNode,
-                     const SharedHandle<DHTNode>& remoteNode,
+  DHTFindNodeMessage(const std::shared_ptr<DHTNode>& localNode,
+                     const std::shared_ptr<DHTNode>& remoteNode,
                      const unsigned char* targetNodeID,
                      const std::string& transactionID = A2STR::NIL);
 
@@ -55,7 +55,7 @@ public:
 
   virtual void doReceivedAction();
 
-  virtual SharedHandle<Dict> getArgument();
+  virtual std::shared_ptr<Dict> getArgument();
 
   virtual const std::string& getMessageType() const;
 
diff --git a/src/DHTFindNodeReplyMessage.cc b/src/DHTFindNodeReplyMessage.cc
index 9669e0ef..74f62366 100644
--- a/src/DHTFindNodeReplyMessage.cc
+++ b/src/DHTFindNodeReplyMessage.cc
@@ -55,8 +55,8 @@ const std::string DHTFindNodeReplyMessage::NODES6("nodes6");
 
 DHTFindNodeReplyMessage::DHTFindNodeReplyMessage
 (int family,
- const SharedHandle<DHTNode>& localNode,
- const SharedHandle<DHTNode>& remoteNode,
+ const std::shared_ptr<DHTNode>& localNode,
+ const std::shared_ptr<DHTNode>& remoteNode,
  const std::string& transactionID):
   DHTResponseMessage(localNode, remoteNode, transactionID),
   family_(family) {}
@@ -65,7 +65,7 @@ DHTFindNodeReplyMessage::~DHTFindNodeReplyMessage() {}
 
 void DHTFindNodeReplyMessage::doReceivedAction()
 {
-  for(std::vector<SharedHandle<DHTNode> >::iterator i = closestKNodes_.begin(),
+  for(std::vector<std::shared_ptr<DHTNode> >::iterator i = closestKNodes_.begin(),
         eoi = closestKNodes_.end(); i != eoi; ++i) {
     if(memcmp((*i)->getID(), getLocalNode()->getID(), DHT_ID_LENGTH) != 0) {
       getRoutingTable()->addNode(*i);
@@ -73,9 +73,9 @@ void DHTFindNodeReplyMessage::doReceivedAction()
   }
 }
 
-SharedHandle<Dict> DHTFindNodeReplyMessage::getResponse()
+std::shared_ptr<Dict> DHTFindNodeReplyMessage::getResponse()
 {
-  SharedHandle<Dict> aDict = Dict::g();
+  std::shared_ptr<Dict> aDict = Dict::g();
   aDict->put(DHTMessage::ID, String::g(getLocalNode()->getID(), DHT_ID_LENGTH));
   unsigned char buffer[DHTBucket::K*38];
   const int clen = bittorrent::getCompactLength(family_);
@@ -83,10 +83,10 @@ SharedHandle<Dict> DHTFindNodeReplyMessage::getResponse()
   assert(unit <= 38);
   size_t offset = 0;
   size_t k = 0;
-  for(std::vector<SharedHandle<DHTNode> >::const_iterator i =
+  for(std::vector<std::shared_ptr<DHTNode> >::const_iterator i =
         closestKNodes_.begin(), eoi = closestKNodes_.end();
       i != eoi && k < DHTBucket::K; ++i) {
-    SharedHandle<DHTNode> node = *i;
+    std::shared_ptr<DHTNode> node = *i;
     memcpy(buffer+offset, node->getID(), DHT_ID_LENGTH);
     unsigned char compact[COMPACT_LEN_IPV6];
     int compactlen = bittorrent::packcompact
@@ -112,7 +112,7 @@ void DHTFindNodeReplyMessage::accept(DHTMessageCallback* callback)
 }
 
 void DHTFindNodeReplyMessage::setClosestKNodes
-(const std::vector<SharedHandle<DHTNode> >& closestKNodes)
+(const std::vector<std::shared_ptr<DHTNode> >& closestKNodes)
 {
   closestKNodes_ = closestKNodes;
 }
diff --git a/src/DHTFindNodeReplyMessage.h b/src/DHTFindNodeReplyMessage.h
index 91f59514..eb62dba1 100644
--- a/src/DHTFindNodeReplyMessage.h
+++ b/src/DHTFindNodeReplyMessage.h
@@ -44,32 +44,32 @@ class DHTFindNodeReplyMessage:public DHTResponseMessage {
 private:
   int family_;
 
-  std::vector<SharedHandle<DHTNode> > closestKNodes_;
+  std::vector<std::shared_ptr<DHTNode> > closestKNodes_;
 protected:
   virtual std::string toStringOptional() const;
 public:
   DHTFindNodeReplyMessage(int family,
-                          const SharedHandle<DHTNode>& localNode,
-                          const SharedHandle<DHTNode>& remoteNode,
+                          const std::shared_ptr<DHTNode>& localNode,
+                          const std::shared_ptr<DHTNode>& remoteNode,
                           const std::string& transactionID);
 
   virtual ~DHTFindNodeReplyMessage();
 
   virtual void doReceivedAction();
 
-  virtual SharedHandle<Dict> getResponse();
+  virtual std::shared_ptr<Dict> getResponse();
 
   virtual const std::string& getMessageType() const;
 
   virtual void accept(DHTMessageCallback* callback);
 
-  const std::vector<SharedHandle<DHTNode> >& getClosestKNodes() const
+  const std::vector<std::shared_ptr<DHTNode> >& getClosestKNodes() const
   {
     return closestKNodes_;
   }
 
   void setClosestKNodes
-  (const std::vector<SharedHandle<DHTNode> >& closestKNodes);
+  (const std::vector<std::shared_ptr<DHTNode> >& closestKNodes);
 
   static const std::string FIND_NODE;
 
diff --git a/src/DHTGetPeersCommand.cc b/src/DHTGetPeersCommand.cc
index ab7ff16b..90e95853 100644
--- a/src/DHTGetPeersCommand.cc
+++ b/src/DHTGetPeersCommand.cc
@@ -130,22 +130,22 @@ bool DHTGetPeersCommand::execute()
   return false;
 }
 
-void DHTGetPeersCommand::setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue)
+void DHTGetPeersCommand::setTaskQueue(const std::shared_ptr<DHTTaskQueue>& taskQueue)
 {
   taskQueue_ = taskQueue;
 }
 
-void DHTGetPeersCommand::setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory)
+void DHTGetPeersCommand::setTaskFactory(const std::shared_ptr<DHTTaskFactory>& taskFactory)
 {
   taskFactory_ = taskFactory;
 }
 
-void DHTGetPeersCommand::setBtRuntime(const SharedHandle<BtRuntime>& btRuntime)
+void DHTGetPeersCommand::setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime)
 {
   btRuntime_ = btRuntime;
 }
 
-void DHTGetPeersCommand::setPeerStorage(const SharedHandle<PeerStorage>& ps)
+void DHTGetPeersCommand::setPeerStorage(const std::shared_ptr<PeerStorage>& ps)
 {
   peerStorage_ = ps;
 }
diff --git a/src/DHTGetPeersCommand.h b/src/DHTGetPeersCommand.h
index 9715709a..03ee64dc 100644
--- a/src/DHTGetPeersCommand.h
+++ b/src/DHTGetPeersCommand.h
@@ -36,7 +36,9 @@
 #define D_DHT_GET_PEERS_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "TimerA2.h"
 
 namespace aria2 {
@@ -54,17 +56,17 @@ class DHTGetPeersCommand:public Command {
 private:
   RequestGroup* requestGroup_;
 
-  SharedHandle<BtRuntime> btRuntime_;
+  std::shared_ptr<BtRuntime> btRuntime_;
 
-  SharedHandle<PeerStorage> peerStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
 
   DownloadEngine* e_;
 
-  SharedHandle<DHTTaskQueue> taskQueue_;
+  std::shared_ptr<DHTTaskQueue> taskQueue_;
 
-  SharedHandle<DHTTaskFactory> taskFactory_;
+  std::shared_ptr<DHTTaskFactory> taskFactory_;
 
-  SharedHandle<DHTTask> task_;
+  std::shared_ptr<DHTTask> task_;
 
   int numRetry_;
 
@@ -77,13 +79,13 @@ public:
 
   virtual bool execute();
 
-  void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);
+  void setTaskQueue(const std::shared_ptr<DHTTaskQueue>& taskQueue);
 
-  void setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory);
+  void setTaskFactory(const std::shared_ptr<DHTTaskFactory>& taskFactory);
 
-  void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime);
+  void setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime);
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 };
 
 } // namespace aria2
diff --git a/src/DHTGetPeersMessage.cc b/src/DHTGetPeersMessage.cc
index 6fd94a2b..0a12814d 100644
--- a/src/DHTGetPeersMessage.cc
+++ b/src/DHTGetPeersMessage.cc
@@ -52,8 +52,8 @@ const std::string DHTGetPeersMessage::GET_PEERS("get_peers");
 
 const std::string DHTGetPeersMessage::INFO_HASH("info_hash");
 
-DHTGetPeersMessage::DHTGetPeersMessage(const SharedHandle<DHTNode>& localNode,
-                                       const SharedHandle<DHTNode>& remoteNode,
+DHTGetPeersMessage::DHTGetPeersMessage(const std::shared_ptr<DHTNode>& localNode,
+                                       const std::shared_ptr<DHTNode>& remoteNode,
                                        const unsigned char* infoHash,
                                        const std::string& transactionID):
   DHTQueryMessage(localNode, remoteNode, transactionID),
@@ -70,19 +70,19 @@ void DHTGetPeersMessage::doReceivedAction()
   std::string token = tokenTracker_->generateToken
     (infoHash_, getRemoteNode()->getIPAddress(), getRemoteNode()->getPort());
   // Check to see localhost has the contents which has same infohash
-  std::vector<SharedHandle<Peer> > peers;
+  std::vector<std::shared_ptr<Peer> > peers;
   peerAnnounceStorage_->getPeers(peers, infoHash_);
-  std::vector<SharedHandle<DHTNode> > nodes;
+  std::vector<std::shared_ptr<DHTNode> > nodes;
   getRoutingTable()->getClosestKNodes(nodes, infoHash_);
-  SharedHandle<DHTMessage> reply =
+  std::shared_ptr<DHTMessage> reply =
     getMessageFactory()->createGetPeersReplyMessage
     (getRemoteNode(), nodes, peers, token, getTransactionID());
   getMessageDispatcher()->addMessageToQueue(reply);
 }
 
-SharedHandle<Dict> DHTGetPeersMessage::getArgument()
+std::shared_ptr<Dict> DHTGetPeersMessage::getArgument()
 {
-  SharedHandle<Dict> aDict = Dict::g();
+  std::shared_ptr<Dict> aDict = Dict::g();
   aDict->put(DHTMessage::ID, String::g(getLocalNode()->getID(), DHT_ID_LENGTH));
   aDict->put(INFO_HASH, String::g(infoHash_, DHT_ID_LENGTH));
   return aDict;
diff --git a/src/DHTGetPeersMessage.h b/src/DHTGetPeersMessage.h
index f6e808bd..c662dc1d 100644
--- a/src/DHTGetPeersMessage.h
+++ b/src/DHTGetPeersMessage.h
@@ -54,8 +54,8 @@ private:
 protected:
   virtual std::string toStringOptional() const;
 public:
-  DHTGetPeersMessage(const SharedHandle<DHTNode>& localNode,
-                     const SharedHandle<DHTNode>& remoteNode,
+  DHTGetPeersMessage(const std::shared_ptr<DHTNode>& localNode,
+                     const std::shared_ptr<DHTNode>& remoteNode,
                      const unsigned char* infoHash,
                      const std::string& transactionID = A2STR::NIL);
 
@@ -63,7 +63,7 @@ public:
 
   virtual void doReceivedAction();
 
-  virtual SharedHandle<Dict> getArgument();
+  virtual std::shared_ptr<Dict> getArgument();
 
   virtual const std::string& getMessageType() const;
 
diff --git a/src/DHTGetPeersReplyMessage.cc b/src/DHTGetPeersReplyMessage.cc
index bb56c9de..f64830ef 100644
--- a/src/DHTGetPeersReplyMessage.cc
+++ b/src/DHTGetPeersReplyMessage.cc
@@ -61,8 +61,8 @@ const std::string DHTGetPeersReplyMessage::NODES6("nodes6");
 
 DHTGetPeersReplyMessage::DHTGetPeersReplyMessage
 (int family,
- const SharedHandle<DHTNode>& localNode,
- const SharedHandle<DHTNode>& remoteNode,
+ const std::shared_ptr<DHTNode>& localNode,
+ const std::shared_ptr<DHTNode>& remoteNode,
  const std::string& token,
  const std::string& transactionID):
   DHTResponseMessage(localNode, remoteNode, transactionID),
@@ -76,9 +76,9 @@ void DHTGetPeersReplyMessage::doReceivedAction()
   // Returned peers and nodes are handled in DHTPeerLookupTask.
 }
 
-SharedHandle<Dict> DHTGetPeersReplyMessage::getResponse()
+std::shared_ptr<Dict> DHTGetPeersReplyMessage::getResponse()
 {
-  SharedHandle<Dict> rDict = Dict::g();
+  std::shared_ptr<Dict> rDict = Dict::g();
   rDict->put(DHTMessage::ID, String::g(getLocalNode()->getID(), DHT_ID_LENGTH));
   rDict->put(TOKEN, token_);
   // TODO want parameter
@@ -88,10 +88,10 @@ SharedHandle<Dict> DHTGetPeersReplyMessage::getResponse()
     const int unit = clen+20;
     size_t offset = 0;
     size_t k = 0;
-    for(std::vector<SharedHandle<DHTNode> >::const_iterator i =
+    for(std::vector<std::shared_ptr<DHTNode> >::const_iterator i =
           closestKNodes_.begin(), eoi = closestKNodes_.end();
         i != eoi && k < DHTBucket::K; ++i) {
-      SharedHandle<DHTNode> node = *i;
+      std::shared_ptr<DHTNode> node = *i;
       memcpy(buffer+offset, node->getID(), DHT_ID_LENGTH);
       unsigned char compact[COMPACT_LEN_IPV6];
       int compactlen = bittorrent::packcompact
@@ -128,11 +128,11 @@ SharedHandle<Dict> DHTGetPeersReplyMessage::getResponse()
     // template may get bigger than 395 bytes. So we use 25 as maximum
     // number of peer info that a message can carry.
     static const size_t MAX_VALUES_SIZE = 25;
-    SharedHandle<List> valuesList = List::g();
-    for(std::vector<SharedHandle<Peer> >::const_iterator i = values_.begin(),
+    std::shared_ptr<List> valuesList = List::g();
+    for(std::vector<std::shared_ptr<Peer> >::const_iterator i = values_.begin(),
           eoi = values_.end(); i != eoi && valuesList->size() < MAX_VALUES_SIZE;
         ++i) {
-      const SharedHandle<Peer>& peer = *i;
+      const std::shared_ptr<Peer>& peer = *i;
       unsigned char compact[COMPACT_LEN_IPV6];
       const int clen = bittorrent::getCompactLength(family_);
       int compactlen = bittorrent::packcompact
diff --git a/src/DHTGetPeersReplyMessage.h b/src/DHTGetPeersReplyMessage.h
index 045abc81..6c7b7882 100644
--- a/src/DHTGetPeersReplyMessage.h
+++ b/src/DHTGetPeersReplyMessage.h
@@ -51,15 +51,15 @@ private:
 
   std::string token_;
 
-  std::vector<SharedHandle<DHTNode> > closestKNodes_;
+  std::vector<std::shared_ptr<DHTNode> > closestKNodes_;
 
-  std::vector<SharedHandle<Peer> > values_;
+  std::vector<std::shared_ptr<Peer> > values_;
 protected:
   virtual std::string toStringOptional() const;
 public:
   DHTGetPeersReplyMessage(int family,
-                          const SharedHandle<DHTNode>& localNode,
-                          const SharedHandle<DHTNode>& remoteNode,
+                          const std::shared_ptr<DHTNode>& localNode,
+                          const std::shared_ptr<DHTNode>& remoteNode,
                           const std::string& token,
                           const std::string& transactionID);
 
@@ -67,29 +67,29 @@ public:
 
   virtual void doReceivedAction();
 
-  virtual SharedHandle<Dict> getResponse();
+  virtual std::shared_ptr<Dict> getResponse();
 
   virtual const std::string& getMessageType() const;
 
   virtual void accept(DHTMessageCallback* callback);
 
-  const std::vector<SharedHandle<DHTNode> >& getClosestKNodes() const
+  const std::vector<std::shared_ptr<DHTNode> >& getClosestKNodes() const
   {
     return closestKNodes_;
   }
 
-  const std::vector<SharedHandle<Peer> >& getValues() const
+  const std::vector<std::shared_ptr<Peer> >& getValues() const
   {
     return values_;
   }
 
   void setClosestKNodes
-  (const std::vector<SharedHandle<DHTNode> >& closestKNodes)
+  (const std::vector<std::shared_ptr<DHTNode> >& closestKNodes)
   {
     closestKNodes_ = closestKNodes;
   }
 
-  void setValues(const std::vector<SharedHandle<Peer> >& peers)
+  void setValues(const std::vector<std::shared_ptr<Peer> >& peers)
   {
     values_ = peers;
   }
diff --git a/src/DHTIDCloser.h b/src/DHTIDCloser.h
index 4d263131..920f197d 100644
--- a/src/DHTIDCloser.h
+++ b/src/DHTIDCloser.h
@@ -48,8 +48,8 @@ private:
 public:
   DHTIDCloser(const unsigned char* targetID):closer_(targetID, DHT_ID_LENGTH) {}
 
-  bool operator()(const SharedHandle<DHTNodeLookupEntry>& m1,
-                  const SharedHandle<DHTNodeLookupEntry>& m2) const
+  bool operator()(const std::shared_ptr<DHTNodeLookupEntry>& m1,
+                  const std::shared_ptr<DHTNodeLookupEntry>& m2) const
   {
     return closer_(m1->node->getID(), m2->node->getID());
   }
diff --git a/src/DHTInteractionCommand.cc b/src/DHTInteractionCommand.cc
index 096812a8..2e6f77ea 100644
--- a/src/DHTInteractionCommand.cc
+++ b/src/DHTInteractionCommand.cc
@@ -66,7 +66,7 @@ DHTInteractionCommand::~DHTInteractionCommand()
   disableReadCheckSocket(readCheckSocket_);
 }
 
-void DHTInteractionCommand::setReadCheckSocket(const SharedHandle<SocketCore>& socket)
+void DHTInteractionCommand::setReadCheckSocket(const std::shared_ptr<SocketCore>& socket)
 {
   readCheckSocket_ = socket;
   if(socket) {
@@ -74,7 +74,7 @@ void DHTInteractionCommand::setReadCheckSocket(const SharedHandle<SocketCore>& s
   }
 }
 
-void DHTInteractionCommand::disableReadCheckSocket(const SharedHandle<SocketCore>& socket)
+void DHTInteractionCommand::disableReadCheckSocket(const std::shared_ptr<SocketCore>& socket)
 {
   if(socket) {
     e_->deleteSocketForReadCheck(socket, this);
@@ -142,29 +142,29 @@ bool DHTInteractionCommand::execute()
   return false;
 }
 
-void DHTInteractionCommand::setMessageDispatcher(const SharedHandle<DHTMessageDispatcher>& dispatcher)
+void DHTInteractionCommand::setMessageDispatcher(const std::shared_ptr<DHTMessageDispatcher>& dispatcher)
 {
   dispatcher_ = dispatcher;
 }
 
-void DHTInteractionCommand::setMessageReceiver(const SharedHandle<DHTMessageReceiver>& receiver)
+void DHTInteractionCommand::setMessageReceiver(const std::shared_ptr<DHTMessageReceiver>& receiver)
 {
   receiver_ = receiver;
 }
 
-void DHTInteractionCommand::setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue)
+void DHTInteractionCommand::setTaskQueue(const std::shared_ptr<DHTTaskQueue>& taskQueue)
 {
   taskQueue_ = taskQueue;
 }
 
 void DHTInteractionCommand::setConnection
-(const SharedHandle<DHTConnection>& connection)
+(const std::shared_ptr<DHTConnection>& connection)
 {
   connection_ = connection;
 }
 
 void DHTInteractionCommand::setUDPTrackerClient
-(const SharedHandle<UDPTrackerClient>& udpTrackerClient)
+(const std::shared_ptr<UDPTrackerClient>& udpTrackerClient)
 {
   udpTrackerClient_ = udpTrackerClient;
 }
diff --git a/src/DHTInteractionCommand.h b/src/DHTInteractionCommand.h
index e90a1dd6..f9de06c9 100644
--- a/src/DHTInteractionCommand.h
+++ b/src/DHTInteractionCommand.h
@@ -36,7 +36,8 @@
 #define D_DHT_INTERACTION_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -51,12 +52,12 @@ class UDPTrackerClient;
 class DHTInteractionCommand:public Command {
 private:
   DownloadEngine* e_;
-  SharedHandle<DHTMessageDispatcher> dispatcher_;
-  SharedHandle<DHTMessageReceiver> receiver_;
-  SharedHandle<DHTTaskQueue> taskQueue_;
-  SharedHandle<SocketCore> readCheckSocket_;
-  SharedHandle<DHTConnection> connection_;
-  SharedHandle<UDPTrackerClient> udpTrackerClient_;
+  std::shared_ptr<DHTMessageDispatcher> dispatcher_;
+  std::shared_ptr<DHTMessageReceiver> receiver_;
+  std::shared_ptr<DHTTaskQueue> taskQueue_;
+  std::shared_ptr<SocketCore> readCheckSocket_;
+  std::shared_ptr<DHTConnection> connection_;
+  std::shared_ptr<UDPTrackerClient> udpTrackerClient_;
 public:
   DHTInteractionCommand(cuid_t cuid, DownloadEngine* e);
 
@@ -64,20 +65,20 @@ public:
 
   virtual bool execute();
 
-  void setReadCheckSocket(const SharedHandle<SocketCore>& socket);
+  void setReadCheckSocket(const std::shared_ptr<SocketCore>& socket);
 
-  void disableReadCheckSocket(const SharedHandle<SocketCore>& socket);
+  void disableReadCheckSocket(const std::shared_ptr<SocketCore>& socket);
 
-  void setMessageDispatcher(const SharedHandle<DHTMessageDispatcher>& dispatcher);
+  void setMessageDispatcher(const std::shared_ptr<DHTMessageDispatcher>& dispatcher);
 
-  void setMessageReceiver(const SharedHandle<DHTMessageReceiver>& receiver);
+  void setMessageReceiver(const std::shared_ptr<DHTMessageReceiver>& receiver);
 
-  void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);
+  void setTaskQueue(const std::shared_ptr<DHTTaskQueue>& taskQueue);
 
-  void setConnection(const SharedHandle<DHTConnection>& connection);
+  void setConnection(const std::shared_ptr<DHTConnection>& connection);
 
   void setUDPTrackerClient
-  (const SharedHandle<UDPTrackerClient>& udpTrackerClient);
+  (const std::shared_ptr<UDPTrackerClient>& udpTrackerClient);
 };
 
 } // namespace aria2
diff --git a/src/DHTMessage.cc b/src/DHTMessage.cc
index 69fea1f4..6a0b52de 100644
--- a/src/DHTMessage.cc
+++ b/src/DHTMessage.cc
@@ -46,8 +46,8 @@ const std::string DHTMessage::V("v");
 
 const std::string DHTMessage::ID("id");
 
-DHTMessage::DHTMessage(const SharedHandle<DHTNode>& localNode,
-                       const SharedHandle<DHTNode>& remoteNode,
+DHTMessage::DHTMessage(const std::shared_ptr<DHTNode>& localNode,
+                       const std::shared_ptr<DHTNode>& remoteNode,
                        const std::string& transactionID):
   localNode_(localNode), remoteNode_(remoteNode), transactionID_(transactionID)
 {
diff --git a/src/DHTMessage.h b/src/DHTMessage.h
index 5a50e801..c5c64b41 100644
--- a/src/DHTMessage.h
+++ b/src/DHTMessage.h
@@ -38,8 +38,8 @@
 #include "common.h"
 
 #include <string>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "A2STR.h"
 
 namespace aria2 {
@@ -48,9 +48,9 @@ class DHTNode;
 
 class DHTMessage {
 private:
-  SharedHandle<DHTNode> localNode_;
+  std::shared_ptr<DHTNode> localNode_;
 
-  SharedHandle<DHTNode> remoteNode_;
+  std::shared_ptr<DHTNode> remoteNode_;
 
   std::string transactionID_;
 
@@ -58,8 +58,8 @@ private:
 
   void generateTransactionID();
 public:
-  DHTMessage(const SharedHandle<DHTNode>& localNode,
-             const SharedHandle<DHTNode>& remoteNode,
+  DHTMessage(const std::shared_ptr<DHTNode>& localNode,
+             const std::shared_ptr<DHTNode>& remoteNode,
              const std::string& transactionID = A2STR::NIL);
 
   virtual ~DHTMessage();
@@ -69,12 +69,12 @@ public:
     return transactionID_;
   }
 
-  const SharedHandle<DHTNode>& getLocalNode() const
+  const std::shared_ptr<DHTNode>& getLocalNode() const
   {
     return localNode_;
   }
 
-  const SharedHandle<DHTNode>& getRemoteNode() const
+  const std::shared_ptr<DHTNode>& getRemoteNode() const
   {
     return remoteNode_;
   }
diff --git a/src/DHTMessageCallback.h b/src/DHTMessageCallback.h
index 3f59eaa4..4dc72d1e 100644
--- a/src/DHTMessageCallback.h
+++ b/src/DHTMessageCallback.h
@@ -36,7 +36,9 @@
 #define D_DHT_MESSAGE_CALLBACK_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "DHTResponseMessage.h"
 
 namespace aria2 {
@@ -51,7 +53,7 @@ class DHTMessageCallback {
 public:
   virtual ~DHTMessageCallback() {}
 
-  void onReceived(const SharedHandle<DHTResponseMessage>& message)
+  void onReceived(const std::shared_ptr<DHTResponseMessage>& message)
   {
     message->accept(this);
   }
@@ -64,7 +66,7 @@ public:
 
   virtual void visit(const DHTPingReplyMessage* message) = 0;
 
-  virtual void onTimeout(const SharedHandle<DHTNode>& remoteNode) = 0;
+  virtual void onTimeout(const std::shared_ptr<DHTNode>& remoteNode) = 0;
 };
 
 } // namespace aria2
diff --git a/src/DHTMessageDispatcher.h b/src/DHTMessageDispatcher.h
index 7f7a64e2..c9285f9e 100644
--- a/src/DHTMessageDispatcher.h
+++ b/src/DHTMessageDispatcher.h
@@ -36,7 +36,9 @@
 #define D_DHT_MESSAGE_DISPATCHER_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "a2time.h"
 
 namespace aria2 {
@@ -49,15 +51,15 @@ public:
   virtual ~DHTMessageDispatcher() {}
 
   virtual void
-  addMessageToQueue(const SharedHandle<DHTMessage>& message,
+  addMessageToQueue(const std::shared_ptr<DHTMessage>& message,
                     time_t timeout,
-                    const SharedHandle<DHTMessageCallback>& callback =
-                    SharedHandle<DHTMessageCallback>()) = 0;
+                    const std::shared_ptr<DHTMessageCallback>& callback =
+                    std::shared_ptr<DHTMessageCallback>()) = 0;
 
   virtual void
-  addMessageToQueue(const SharedHandle<DHTMessage>& message,
-                    const SharedHandle<DHTMessageCallback>& callback =
-                    SharedHandle<DHTMessageCallback>()) = 0;
+  addMessageToQueue(const std::shared_ptr<DHTMessage>& message,
+                    const std::shared_ptr<DHTMessageCallback>& callback =
+                    std::shared_ptr<DHTMessageCallback>()) = 0;
 
   virtual void sendMessages() = 0;
 
diff --git a/src/DHTMessageDispatcherImpl.cc b/src/DHTMessageDispatcherImpl.cc
index f9ff0ac1..8cdf4c52 100644
--- a/src/DHTMessageDispatcherImpl.cc
+++ b/src/DHTMessageDispatcherImpl.cc
@@ -47,7 +47,7 @@
 namespace aria2 {
 
 DHTMessageDispatcherImpl::DHTMessageDispatcherImpl
-(const SharedHandle<DHTMessageTracker>& tracker)
+(const std::shared_ptr<DHTMessageTracker>& tracker)
   : tracker_(tracker),
     timeout_(DHT_MESSAGE_TIMEOUT)
 {}
@@ -56,26 +56,26 @@ DHTMessageDispatcherImpl::~DHTMessageDispatcherImpl() {}
 
 void
 DHTMessageDispatcherImpl::addMessageToQueue
-(const SharedHandle<DHTMessage>& message,
+(const std::shared_ptr<DHTMessage>& message,
  time_t timeout,
- const SharedHandle<DHTMessageCallback>& callback)
+ const std::shared_ptr<DHTMessageCallback>& callback)
 {
-  SharedHandle<DHTMessageEntry> e
+  std::shared_ptr<DHTMessageEntry> e
     (new DHTMessageEntry(message, timeout, callback));
   messageQueue_.push_back(e);
 }
 
 void
 DHTMessageDispatcherImpl::addMessageToQueue
-(const SharedHandle<DHTMessage>& message,
- const SharedHandle<DHTMessageCallback>& callback)
+(const std::shared_ptr<DHTMessage>& message,
+ const std::shared_ptr<DHTMessageCallback>& callback)
 {
   addMessageToQueue(message, timeout_, callback);
 }
 
 bool
 DHTMessageDispatcherImpl::sendMessage
-(const SharedHandle<DHTMessageEntry>& entry)
+(const std::shared_ptr<DHTMessageEntry>& entry)
 {
   try {
     if(entry->message->send()) {
@@ -105,7 +105,7 @@ void DHTMessageDispatcherImpl::sendMessages()
 {
   // TODO I can't use bind1st and mem_fun here because bind1st cannot bind a
   // function which takes a reference as an argument..
-  std::deque<SharedHandle<DHTMessageEntry> >::iterator itr =
+  std::deque<std::shared_ptr<DHTMessageEntry> >::iterator itr =
     messageQueue_.begin();
   for(; itr != messageQueue_.end(); ++itr) {
     if(!sendMessage(*itr)) {
diff --git a/src/DHTMessageDispatcherImpl.h b/src/DHTMessageDispatcherImpl.h
index d0f2090e..68767234 100644
--- a/src/DHTMessageDispatcherImpl.h
+++ b/src/DHTMessageDispatcherImpl.h
@@ -45,28 +45,28 @@ struct DHTMessageEntry;
 
 class DHTMessageDispatcherImpl:public DHTMessageDispatcher {
 private:
-  SharedHandle<DHTMessageTracker> tracker_;
+  std::shared_ptr<DHTMessageTracker> tracker_;
 
-  std::deque<SharedHandle<DHTMessageEntry> > messageQueue_;
+  std::deque<std::shared_ptr<DHTMessageEntry> > messageQueue_;
 
   time_t timeout_;
 
-  bool sendMessage(const SharedHandle<DHTMessageEntry>& msg);
+  bool sendMessage(const std::shared_ptr<DHTMessageEntry>& msg);
 public:
-  DHTMessageDispatcherImpl(const SharedHandle<DHTMessageTracker>& tracker);
+  DHTMessageDispatcherImpl(const std::shared_ptr<DHTMessageTracker>& tracker);
 
   virtual ~DHTMessageDispatcherImpl();
 
   virtual void
-  addMessageToQueue(const SharedHandle<DHTMessage>& message,
+  addMessageToQueue(const std::shared_ptr<DHTMessage>& message,
                     time_t timeout,
-                    const SharedHandle<DHTMessageCallback>& callback =
-                    SharedHandle<DHTMessageCallback>());
+                    const std::shared_ptr<DHTMessageCallback>& callback =
+                    std::shared_ptr<DHTMessageCallback>());
 
   virtual void
-  addMessageToQueue(const SharedHandle<DHTMessage>& message,
-                    const SharedHandle<DHTMessageCallback>& callback =
-                    SharedHandle<DHTMessageCallback>());
+  addMessageToQueue(const std::shared_ptr<DHTMessage>& message,
+                    const std::shared_ptr<DHTMessageCallback>& callback =
+                    std::shared_ptr<DHTMessageCallback>());
 
   virtual void sendMessages();
 
diff --git a/src/DHTMessageEntry.cc b/src/DHTMessageEntry.cc
index 6eaafe5d..1c2f4cd7 100644
--- a/src/DHTMessageEntry.cc
+++ b/src/DHTMessageEntry.cc
@@ -40,9 +40,9 @@
 namespace aria2 {
 
 DHTMessageEntry::DHTMessageEntry
-(const SharedHandle<DHTMessage>& message,
+(const std::shared_ptr<DHTMessage>& message,
  time_t timeout,
- const SharedHandle<DHTMessageCallback>& callback):
+ const std::shared_ptr<DHTMessageCallback>& callback):
   message(message),
   timeout(timeout),
   callback(callback) {}
diff --git a/src/DHTMessageEntry.h b/src/DHTMessageEntry.h
index 92c71064..2698b5ae 100644
--- a/src/DHTMessageEntry.h
+++ b/src/DHTMessageEntry.h
@@ -36,7 +36,9 @@
 #define D_DHT_MESSAGE_ENTRY_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "a2time.h"
 
 namespace aria2 {
@@ -45,13 +47,13 @@ class DHTMessage;
 class DHTMessageCallback;
 
 struct DHTMessageEntry {
-  SharedHandle<DHTMessage> message;
+  std::shared_ptr<DHTMessage> message;
   time_t timeout;
-  SharedHandle<DHTMessageCallback> callback;
+  std::shared_ptr<DHTMessageCallback> callback;
 
-  DHTMessageEntry(const SharedHandle<DHTMessage>& message,
+  DHTMessageEntry(const std::shared_ptr<DHTMessage>& message,
                   time_t timeout,
-                  const SharedHandle<DHTMessageCallback>& callback);
+                  const std::shared_ptr<DHTMessageCallback>& callback);
 
   ~DHTMessageEntry();
 };
diff --git a/src/DHTMessageFactory.h b/src/DHTMessageFactory.h
index 40e9c852..2d8a8ad3 100644
--- a/src/DHTMessageFactory.h
+++ b/src/DHTMessageFactory.h
@@ -39,8 +39,8 @@
 
 #include <string>
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "A2STR.h"
 #include "ValueBase.h"
 
@@ -56,60 +56,60 @@ class DHTMessageFactory {
 public:
   virtual ~DHTMessageFactory() {}
 
-  virtual SharedHandle<DHTQueryMessage>
+  virtual std::shared_ptr<DHTQueryMessage>
   createQueryMessage(const Dict* dict,
                      const std::string& ipaddr, uint16_t port) = 0;
 
-  virtual SharedHandle<DHTResponseMessage>
+  virtual std::shared_ptr<DHTResponseMessage>
   createResponseMessage(const std::string& messageType,
                         const Dict* dict,
                         const std::string& ipaddr, uint16_t port) = 0;
 
-  virtual SharedHandle<DHTQueryMessage>
-  createPingMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTQueryMessage>
+  createPingMessage(const std::shared_ptr<DHTNode>& remoteNode,
                     const std::string& transactionID = A2STR::NIL) = 0;
 
-  virtual SharedHandle<DHTResponseMessage>
-  createPingReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTResponseMessage>
+  createPingReplyMessage(const std::shared_ptr<DHTNode>& remoteNode,
                          const unsigned char* id,
                          const std::string& transactionID) = 0;
 
-  virtual SharedHandle<DHTQueryMessage>
-  createFindNodeMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTQueryMessage>
+  createFindNodeMessage(const std::shared_ptr<DHTNode>& remoteNode,
                         const unsigned char* targetNodeID,
                         const std::string& transactionID = A2STR::NIL) = 0;
 
-  virtual SharedHandle<DHTResponseMessage>
+  virtual std::shared_ptr<DHTResponseMessage>
   createFindNodeReplyMessage
-  (const SharedHandle<DHTNode>& remoteNode,
-   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+  (const std::shared_ptr<DHTNode>& remoteNode,
+   const std::vector<std::shared_ptr<DHTNode> >& closestKNodes,
    const std::string& transactionID) = 0;
 
-  virtual SharedHandle<DHTQueryMessage>
-  createGetPeersMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTQueryMessage>
+  createGetPeersMessage(const std::shared_ptr<DHTNode>& remoteNode,
                         const unsigned char* infoHash,
                         const std::string& transactionID = A2STR::NIL) = 0;
 
-  virtual SharedHandle<DHTResponseMessage>
+  virtual std::shared_ptr<DHTResponseMessage>
   createGetPeersReplyMessage
-  (const SharedHandle<DHTNode>& remoteNode,
-   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
-   const std::vector<SharedHandle<Peer> >& peers,
+  (const std::shared_ptr<DHTNode>& remoteNode,
+   const std::vector<std::shared_ptr<DHTNode> >& closestKNodes,
+   const std::vector<std::shared_ptr<Peer> >& peers,
    const std::string& token,
    const std::string& transactionID) = 0;
 
-  virtual SharedHandle<DHTQueryMessage>
-  createAnnouncePeerMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTQueryMessage>
+  createAnnouncePeerMessage(const std::shared_ptr<DHTNode>& remoteNode,
                             const unsigned char* infoHash,
                             uint16_t tcpPort,
                             const std::string& token,
                             const std::string& transactionID = A2STR::NIL) = 0;
 
-  virtual SharedHandle<DHTResponseMessage>
-  createAnnouncePeerReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTResponseMessage>
+  createAnnouncePeerReplyMessage(const std::shared_ptr<DHTNode>& remoteNode,
                                  const std::string& transactionID) = 0;
 
-  virtual SharedHandle<DHTMessage>
+  virtual std::shared_ptr<DHTMessage>
   createUnknownMessage(const unsigned char* data, size_t length,
                        const std::string& ipaddr, uint16_t port) = 0;
 };
diff --git a/src/DHTMessageFactoryImpl.cc b/src/DHTMessageFactoryImpl.cc
index 4e09db3b..f1d07c2b 100644
--- a/src/DHTMessageFactoryImpl.cc
+++ b/src/DHTMessageFactoryImpl.cc
@@ -75,11 +75,11 @@ DHTMessageFactoryImpl::DHTMessageFactoryImpl(int family)
 
 DHTMessageFactoryImpl::~DHTMessageFactoryImpl() {}
 
-SharedHandle<DHTNode>
+std::shared_ptr<DHTNode>
 DHTMessageFactoryImpl::getRemoteNode
 (const unsigned char* id, const std::string& ipaddr, uint16_t port) const
 {
-  SharedHandle<DHTNode> node = routingTable_->getNode(id, ipaddr, port);
+  std::shared_ptr<DHTNode> node = routingTable_->getNode(id, ipaddr, port);
   if(!node) {
     node.reset(new DHTNode(id));
     node->setIPAddress(ipaddr);
@@ -188,7 +188,7 @@ void DHTMessageFactoryImpl::validatePort(const Integer* port) const
 }
 
 namespace {
-void setVersion(const SharedHandle<DHTMessage>& msg, const Dict* dict)
+void setVersion(const std::shared_ptr<DHTMessage>& msg, const Dict* dict)
 {
   const String* v = downcast<String>(dict->get(DHTMessage::V));
   if(v) {
@@ -199,7 +199,7 @@ void setVersion(const SharedHandle<DHTMessage>& msg, const Dict* dict)
 }
 } // namespace
 
-SharedHandle<DHTQueryMessage> DHTMessageFactoryImpl::createQueryMessage
+std::shared_ptr<DHTQueryMessage> DHTMessageFactoryImpl::createQueryMessage
 (const Dict* dict, const std::string& ipaddr, uint16_t port)
 {
   const String* messageType = getString(dict, DHTQueryMessage::Q);
@@ -211,8 +211,8 @@ SharedHandle<DHTQueryMessage> DHTMessageFactoryImpl::createQueryMessage
   }
   const String* id = getString(aDict, DHTMessage::ID);
   validateID(id);
-  SharedHandle<DHTNode> remoteNode = getRemoteNode(id->uc(), ipaddr, port);
-  SharedHandle<DHTQueryMessage> msg;
+  std::shared_ptr<DHTNode> remoteNode = getRemoteNode(id->uc(), ipaddr, port);
+  std::shared_ptr<DHTQueryMessage> msg;
   if(messageType->s() == DHTPingMessage::PING) {
     msg = createPingMessage(remoteNode, transactionID->s());
   } else if(messageType->s() == DHTFindNodeMessage::FIND_NODE) {
@@ -242,7 +242,7 @@ SharedHandle<DHTQueryMessage> DHTMessageFactoryImpl::createQueryMessage
   return msg;
 }
 
-SharedHandle<DHTResponseMessage>
+std::shared_ptr<DHTResponseMessage>
 DHTMessageFactoryImpl::createResponseMessage
 (const std::string& messageType,
  const Dict* dict,
@@ -270,8 +270,8 @@ DHTMessageFactoryImpl::createResponseMessage
   const Dict* rDict = getDictionary(dict, DHTResponseMessage::R);
   const String* id = getString(rDict, DHTMessage::ID);
   validateID(id);
-  SharedHandle<DHTNode> remoteNode = getRemoteNode(id->uc(), ipaddr, port);
-  SharedHandle<DHTResponseMessage> msg;
+  std::shared_ptr<DHTNode> remoteNode = getRemoteNode(id->uc(), ipaddr, port);
+  std::shared_ptr<DHTResponseMessage> msg;
   if(messageType == DHTPingReplyMessage::PING) {
     msg = createPingReplyMessage(remoteNode, id->uc(), transactionID->s());
   } else if(messageType == DHTFindNodeReplyMessage::FIND_NODE) {
@@ -312,51 +312,51 @@ void DHTMessageFactoryImpl::setCommonProperty(DHTAbstractMessage* m)
   m->setVersion(getDefaultVersion());
 }
 
-SharedHandle<DHTQueryMessage> DHTMessageFactoryImpl::createPingMessage
-(const SharedHandle<DHTNode>& remoteNode, const std::string& transactionID)
+std::shared_ptr<DHTQueryMessage> DHTMessageFactoryImpl::createPingMessage
+(const std::shared_ptr<DHTNode>& remoteNode, const std::string& transactionID)
 {
   DHTPingMessage* m(new DHTPingMessage(localNode_, remoteNode, transactionID));
   setCommonProperty(m);
-  return SharedHandle<DHTQueryMessage>(m);
+  return std::shared_ptr<DHTQueryMessage>(m);
 }
 
-SharedHandle<DHTResponseMessage> DHTMessageFactoryImpl::createPingReplyMessage
-(const SharedHandle<DHTNode>& remoteNode,
+std::shared_ptr<DHTResponseMessage> DHTMessageFactoryImpl::createPingReplyMessage
+(const std::shared_ptr<DHTNode>& remoteNode,
  const unsigned char* id,
  const std::string& transactionID)
 {
   DHTPingReplyMessage* m
     (new DHTPingReplyMessage(localNode_, remoteNode, id, transactionID));
   setCommonProperty(m);
-  return SharedHandle<DHTResponseMessage>(m);
+  return std::shared_ptr<DHTResponseMessage>(m);
 }
 
-SharedHandle<DHTQueryMessage> DHTMessageFactoryImpl::createFindNodeMessage
-(const SharedHandle<DHTNode>& remoteNode,
+std::shared_ptr<DHTQueryMessage> DHTMessageFactoryImpl::createFindNodeMessage
+(const std::shared_ptr<DHTNode>& remoteNode,
  const unsigned char* targetNodeID,
  const std::string& transactionID)
 {
   DHTFindNodeMessage* m(new DHTFindNodeMessage
                         (localNode_, remoteNode, targetNodeID, transactionID));
   setCommonProperty(m);
-  return SharedHandle<DHTQueryMessage>(m);
+  return std::shared_ptr<DHTQueryMessage>(m);
 }
 
-SharedHandle<DHTResponseMessage>
+std::shared_ptr<DHTResponseMessage>
 DHTMessageFactoryImpl::createFindNodeReplyMessage
-(const SharedHandle<DHTNode>& remoteNode,
- const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+(const std::shared_ptr<DHTNode>& remoteNode,
+ const std::vector<std::shared_ptr<DHTNode> >& closestKNodes,
  const std::string& transactionID)
 {
   DHTFindNodeReplyMessage* m(new DHTFindNodeReplyMessage
                              (family_, localNode_, remoteNode, transactionID));
   m->setClosestKNodes(closestKNodes);
   setCommonProperty(m);
-  return SharedHandle<DHTResponseMessage>(m);
+  return std::shared_ptr<DHTResponseMessage>(m);
 }
 
 void DHTMessageFactoryImpl::extractNodes
-(std::vector<SharedHandle<DHTNode> >& nodes,
+(std::vector<std::shared_ptr<DHTNode> >& nodes,
  const unsigned char* src, size_t length)
 {
   int unit = bittorrent::getCompactLength(family_)+20;
@@ -365,7 +365,7 @@ void DHTMessageFactoryImpl::extractNodes
       (fmt("Nodes length is not multiple of %d", unit));
   }
   for(size_t offset = 0; offset < length; offset += unit) {
-    SharedHandle<DHTNode> node(new DHTNode(src+offset));
+    std::shared_ptr<DHTNode> node(new DHTNode(src+offset));
     std::pair<std::string, uint16_t> addr =
       bittorrent::unpackcompact(src+offset+DHT_ID_LENGTH, family_);
     if(addr.first.empty()) {
@@ -377,9 +377,9 @@ void DHTMessageFactoryImpl::extractNodes
   }
 }
 
-SharedHandle<DHTResponseMessage>
+std::shared_ptr<DHTResponseMessage>
 DHTMessageFactoryImpl::createFindNodeReplyMessage
-(const SharedHandle<DHTNode>& remoteNode,
+(const std::shared_ptr<DHTNode>& remoteNode,
  const Dict* dict,
  const std::string& transactionID)
 {
@@ -387,16 +387,16 @@ DHTMessageFactoryImpl::createFindNodeReplyMessage
     downcast<String>(getDictionary(dict, DHTResponseMessage::R)->
              get(family_ == AF_INET?DHTFindNodeReplyMessage::NODES:
                  DHTFindNodeReplyMessage::NODES6));
-  std::vector<SharedHandle<DHTNode> > nodes;
+  std::vector<std::shared_ptr<DHTNode> > nodes;
   if(nodesData) {
     extractNodes(nodes, nodesData->uc(), nodesData->s().size());
   }
   return createFindNodeReplyMessage(remoteNode, nodes, transactionID);
 }
 
-SharedHandle<DHTQueryMessage>
+std::shared_ptr<DHTQueryMessage>
 DHTMessageFactoryImpl::createGetPeersMessage
-(const SharedHandle<DHTNode>& remoteNode,
+(const std::shared_ptr<DHTNode>& remoteNode,
  const unsigned char* infoHash,
  const std::string& transactionID)
 {
@@ -405,12 +405,12 @@ DHTMessageFactoryImpl::createGetPeersMessage
   m->setPeerAnnounceStorage(peerAnnounceStorage_);
   m->setTokenTracker(tokenTracker_);
   setCommonProperty(m);
-  return SharedHandle<DHTQueryMessage>(m);
+  return std::shared_ptr<DHTQueryMessage>(m);
 }
 
-SharedHandle<DHTResponseMessage>
+std::shared_ptr<DHTResponseMessage>
 DHTMessageFactoryImpl::createGetPeersReplyMessage
-(const SharedHandle<DHTNode>& remoteNode,
+(const std::shared_ptr<DHTNode>& remoteNode,
  const Dict* dict,
  const std::string& transactionID)
 {
@@ -418,13 +418,13 @@ DHTMessageFactoryImpl::createGetPeersReplyMessage
   const String* nodesData =
     downcast<String>(rDict->get(family_ == AF_INET?DHTGetPeersReplyMessage::NODES:
                         DHTGetPeersReplyMessage::NODES6));
-  std::vector<SharedHandle<DHTNode> > nodes;
+  std::vector<std::shared_ptr<DHTNode> > nodes;
   if(nodesData) {
     extractNodes(nodes, nodesData->uc(), nodesData->s().size());
   }
   const List* valuesList =
     downcast<List>(rDict->get(DHTGetPeersReplyMessage::VALUES));
-  std::vector<SharedHandle<Peer> > peers;
+  std::vector<std::shared_ptr<Peer> > peers;
   size_t clen = bittorrent::getCompactLength(family_);
   if(valuesList) {
     for(List::ValueType::const_iterator i = valuesList->begin(),
@@ -436,7 +436,7 @@ DHTMessageFactoryImpl::createGetPeersReplyMessage
         if(addr.first.empty()) {
           continue;
         }
-        SharedHandle<Peer> peer(new Peer(addr.first, addr.second));
+        std::shared_ptr<Peer> peer(new Peer(addr.first, addr.second));
         peers.push_back(peer);
       }
     }
@@ -446,11 +446,11 @@ DHTMessageFactoryImpl::createGetPeersReplyMessage
     (remoteNode, nodes, peers, token->s(), transactionID);
 }
 
-SharedHandle<DHTResponseMessage>
+std::shared_ptr<DHTResponseMessage>
 DHTMessageFactoryImpl::createGetPeersReplyMessage
-(const SharedHandle<DHTNode>& remoteNode,
- const std::vector<SharedHandle<DHTNode> >& closestKNodes,
- const std::vector<SharedHandle<Peer> >& values,
+(const std::shared_ptr<DHTNode>& remoteNode,
+ const std::vector<std::shared_ptr<DHTNode> >& closestKNodes,
+ const std::vector<std::shared_ptr<Peer> >& values,
  const std::string& token,
  const std::string& transactionID)
 {
@@ -460,12 +460,12 @@ DHTMessageFactoryImpl::createGetPeersReplyMessage
   m->setClosestKNodes(closestKNodes);
   m->setValues(values);
   setCommonProperty(m);
-  return SharedHandle<DHTResponseMessage>(m);
+  return std::shared_ptr<DHTResponseMessage>(m);
 }
 
-SharedHandle<DHTQueryMessage>
+std::shared_ptr<DHTQueryMessage>
 DHTMessageFactoryImpl::createAnnouncePeerMessage
-(const SharedHandle<DHTNode>& remoteNode,
+(const std::shared_ptr<DHTNode>& remoteNode,
  const unsigned char* infoHash,
  uint16_t tcpPort,
  const std::string& token,
@@ -477,20 +477,20 @@ DHTMessageFactoryImpl::createAnnouncePeerMessage
   m->setPeerAnnounceStorage(peerAnnounceStorage_);
   m->setTokenTracker(tokenTracker_);
   setCommonProperty(m);
-  return SharedHandle<DHTQueryMessage>(m);
+  return std::shared_ptr<DHTQueryMessage>(m);
 }
 
-SharedHandle<DHTResponseMessage>
+std::shared_ptr<DHTResponseMessage>
 DHTMessageFactoryImpl::createAnnouncePeerReplyMessage
-(const SharedHandle<DHTNode>& remoteNode, const std::string& transactionID)
+(const std::shared_ptr<DHTNode>& remoteNode, const std::string& transactionID)
 {
   DHTAnnouncePeerReplyMessage* m
     (new DHTAnnouncePeerReplyMessage(localNode_, remoteNode, transactionID));
   setCommonProperty(m);
-  return SharedHandle<DHTResponseMessage>(m);
+  return std::shared_ptr<DHTResponseMessage>(m);
 }
 
-SharedHandle<DHTMessage>
+std::shared_ptr<DHTMessage>
 DHTMessageFactoryImpl::createUnknownMessage
 (const unsigned char* data, size_t length,
  const std::string& ipaddr, uint16_t port)
@@ -498,7 +498,7 @@ DHTMessageFactoryImpl::createUnknownMessage
 {
   DHTUnknownMessage* m
     (new DHTUnknownMessage(localNode_, data, length, ipaddr, port));
-  return SharedHandle<DHTMessage>(m);
+  return std::shared_ptr<DHTMessage>(m);
 }
 
 void DHTMessageFactoryImpl::setRoutingTable(DHTRoutingTable* routingTable)
@@ -529,7 +529,7 @@ void DHTMessageFactoryImpl::setTokenTracker(DHTTokenTracker* tokenTracker)
 }
 
 void DHTMessageFactoryImpl::setLocalNode
-(const SharedHandle<DHTNode>& localNode)
+(const std::shared_ptr<DHTNode>& localNode)
 {
   localNode_ = localNode;
 }
diff --git a/src/DHTMessageFactoryImpl.h b/src/DHTMessageFactoryImpl.h
index 87738b44..cafdcbd3 100644
--- a/src/DHTMessageFactoryImpl.h
+++ b/src/DHTMessageFactoryImpl.h
@@ -52,7 +52,7 @@ class DHTMessageFactoryImpl:public DHTMessageFactory {
 private:
   int family_;
 
-  SharedHandle<DHTNode> localNode_;
+  std::shared_ptr<DHTNode> localNode_;
 
   DHTConnection* connection_;
 
@@ -65,7 +65,7 @@ private:
   DHTTokenTracker* tokenTracker_;
 
   // search node in routingTable. If it is not found, create new one.
-  SharedHandle<DHTNode> getRemoteNode
+  std::shared_ptr<DHTNode> getRemoteNode
   (const unsigned char* id, const std::string& ipaddr, uint16_t port) const;
 
   void validateID(const String* id) const;
@@ -73,7 +73,7 @@ private:
   void validatePort(const Integer* i) const;
 
   void extractNodes
-  (std::vector<SharedHandle<DHTNode> >& nodes,
+  (std::vector<std::shared_ptr<DHTNode> >& nodes,
    const unsigned char* src, size_t length);
 
   void setCommonProperty(DHTAbstractMessage* m);
@@ -83,72 +83,72 @@ public:
 
   virtual ~DHTMessageFactoryImpl();
 
-  virtual SharedHandle<DHTQueryMessage>
+  virtual std::shared_ptr<DHTQueryMessage>
   createQueryMessage(const Dict* dict,
                      const std::string& ipaddr, uint16_t port);
 
-  virtual SharedHandle<DHTResponseMessage>
+  virtual std::shared_ptr<DHTResponseMessage>
   createResponseMessage(const std::string& messageType,
                         const Dict* dict,
                         const std::string& ipaddr, uint16_t port);
 
-  virtual SharedHandle<DHTQueryMessage>
-  createPingMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTQueryMessage>
+  createPingMessage(const std::shared_ptr<DHTNode>& remoteNode,
                     const std::string& transactionID = A2STR::NIL);
 
-  virtual SharedHandle<DHTResponseMessage>
-  createPingReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTResponseMessage>
+  createPingReplyMessage(const std::shared_ptr<DHTNode>& remoteNode,
                          const unsigned char* id,
                          const std::string& transactionID);
 
-  virtual SharedHandle<DHTQueryMessage>
-  createFindNodeMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTQueryMessage>
+  createFindNodeMessage(const std::shared_ptr<DHTNode>& remoteNode,
                         const unsigned char* targetNodeID,
                         const std::string& transactionID = A2STR::NIL);
 
-  SharedHandle<DHTResponseMessage>
-  createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+  std::shared_ptr<DHTResponseMessage>
+  createFindNodeReplyMessage(const std::shared_ptr<DHTNode>& remoteNode,
                              const Dict* dict,
                              const std::string& transactionID);
 
 
-  virtual SharedHandle<DHTResponseMessage>
+  virtual std::shared_ptr<DHTResponseMessage>
   createFindNodeReplyMessage
-  (const SharedHandle<DHTNode>& remoteNode,
-   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+  (const std::shared_ptr<DHTNode>& remoteNode,
+   const std::vector<std::shared_ptr<DHTNode> >& closestKNodes,
    const std::string& transactionID);
 
-  virtual SharedHandle<DHTQueryMessage>
-  createGetPeersMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTQueryMessage>
+  createGetPeersMessage(const std::shared_ptr<DHTNode>& remoteNode,
                         const unsigned char* infoHash,
                         const std::string& transactionID = A2STR::NIL);
 
-  virtual SharedHandle<DHTResponseMessage>
+  virtual std::shared_ptr<DHTResponseMessage>
   createGetPeersReplyMessage
-  (const SharedHandle<DHTNode>& remoteNode,
-   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
-   const std::vector<SharedHandle<Peer> >& peers,
+  (const std::shared_ptr<DHTNode>& remoteNode,
+   const std::vector<std::shared_ptr<DHTNode> >& closestKNodes,
+   const std::vector<std::shared_ptr<Peer> >& peers,
    const std::string& token,
    const std::string& transactionID);
 
-  SharedHandle<DHTResponseMessage>
+  std::shared_ptr<DHTResponseMessage>
   createGetPeersReplyMessage
-  (const SharedHandle<DHTNode>& remoteNode,
+  (const std::shared_ptr<DHTNode>& remoteNode,
    const Dict* dict,
    const std::string& transactionID);
 
-  virtual SharedHandle<DHTQueryMessage>
-  createAnnouncePeerMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTQueryMessage>
+  createAnnouncePeerMessage(const std::shared_ptr<DHTNode>& remoteNode,
                             const unsigned char* infoHash,
                             uint16_t tcpPort,
                             const std::string& token,
                             const std::string& transactionID = A2STR::NIL);
 
-  virtual SharedHandle<DHTResponseMessage>
-  createAnnouncePeerReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTResponseMessage>
+  createAnnouncePeerReplyMessage(const std::shared_ptr<DHTNode>& remoteNode,
                                  const std::string& transactionID);
 
-  virtual SharedHandle<DHTMessage>
+  virtual std::shared_ptr<DHTMessage>
   createUnknownMessage(const unsigned char* data, size_t length,
                        const std::string& ipaddr, uint16_t port);
 
@@ -162,7 +162,7 @@ public:
 
   void setTokenTracker(DHTTokenTracker* tokenTracker);
 
-  void setLocalNode(const SharedHandle<DHTNode>& localNode);
+  void setLocalNode(const std::shared_ptr<DHTNode>& localNode);
 };
 
 } // namespace aria2
diff --git a/src/DHTMessageReceiver.cc b/src/DHTMessageReceiver.cc
index 36e40639..ec6ad904 100644
--- a/src/DHTMessageReceiver.cc
+++ b/src/DHTMessageReceiver.cc
@@ -57,19 +57,19 @@
 namespace aria2 {
 
 DHTMessageReceiver::DHTMessageReceiver
-(const SharedHandle<DHTMessageTracker>& tracker)
+(const std::shared_ptr<DHTMessageTracker>& tracker)
   : tracker_(tracker)
 {}
 
 DHTMessageReceiver::~DHTMessageReceiver() {}
 
-SharedHandle<DHTMessage> DHTMessageReceiver::receiveMessage
+std::shared_ptr<DHTMessage> DHTMessageReceiver::receiveMessage
 (const std::string& remoteAddr, uint16_t remotePort, unsigned char *data,
  size_t length)
 {
   try {
     bool isReply = false;
-    SharedHandle<ValueBase> decoded = bencode2::decode(data, length);
+    std::shared_ptr<ValueBase> decoded = bencode2::decode(data, length);
     const Dict* dict = downcast<Dict>(decoded);
     if(dict) {
       const String* y = downcast<String>(dict->get(DHTMessage::Y));
@@ -89,8 +89,8 @@ SharedHandle<DHTMessage> DHTMessageReceiver::receiveMessage
       return handleUnknownMessage(data, length, remoteAddr, remotePort);
     }
     if(isReply) {
-      std::pair<SharedHandle<DHTResponseMessage>,
-                SharedHandle<DHTMessageCallback> > p =
+      std::pair<std::shared_ptr<DHTResponseMessage>,
+                std::shared_ptr<DHTMessageCallback> > p =
         tracker_->messageArrived(dict, remoteAddr, remotePort);
       if(!p.first) {
         // timeout or malicious? message
@@ -102,7 +102,7 @@ SharedHandle<DHTMessage> DHTMessageReceiver::receiveMessage
       }
       return p.first;
     } else {
-      SharedHandle<DHTQueryMessage> message =
+      std::shared_ptr<DHTQueryMessage> message =
         factory_->createQueryMessage(dict, remoteAddr, remotePort);
       if(*message->getLocalNode() == *message->getRemoteNode()) {
         // drop message from localnode
@@ -119,7 +119,7 @@ SharedHandle<DHTMessage> DHTMessageReceiver::receiveMessage
 }
 
 void DHTMessageReceiver::onMessageReceived
-(const SharedHandle<DHTMessage>& message)
+(const std::shared_ptr<DHTMessage>& message)
 {
   A2_LOG_INFO(fmt("Message received: %s", message->toString().c_str()));
   message->validate();
@@ -134,29 +134,29 @@ void DHTMessageReceiver::handleTimeout()
   tracker_->handleTimeout();
 }
 
-SharedHandle<DHTMessage>
+std::shared_ptr<DHTMessage>
 DHTMessageReceiver::handleUnknownMessage(const unsigned char* data,
                                          size_t length,
                                          const std::string& remoteAddr,
                                          uint16_t remotePort)
 {
-  SharedHandle<DHTMessage> m =
+  std::shared_ptr<DHTMessage> m =
     factory_->createUnknownMessage(data, length, remoteAddr, remotePort);
   A2_LOG_INFO(fmt("Message received: %s", m->toString().c_str()));
   return m;
 }
 
-void DHTMessageReceiver::setConnection(const SharedHandle<DHTConnection>& connection)
+void DHTMessageReceiver::setConnection(const std::shared_ptr<DHTConnection>& connection)
 {
   connection_ = connection;
 }
 
-void DHTMessageReceiver::setMessageFactory(const SharedHandle<DHTMessageFactory>& factory)
+void DHTMessageReceiver::setMessageFactory(const std::shared_ptr<DHTMessageFactory>& factory)
 {
   factory_ = factory;
 }
 
-void DHTMessageReceiver::setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable)
+void DHTMessageReceiver::setRoutingTable(const std::shared_ptr<DHTRoutingTable>& routingTable)
 {
   routingTable_ = routingTable;
 }
diff --git a/src/DHTMessageReceiver.h b/src/DHTMessageReceiver.h
index f8ed5018..6b008aef 100644
--- a/src/DHTMessageReceiver.h
+++ b/src/DHTMessageReceiver.h
@@ -38,8 +38,7 @@
 #include "common.h"
 
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -51,45 +50,45 @@ class DHTRoutingTable;
 
 class DHTMessageReceiver {
 private:
-  SharedHandle<DHTMessageTracker> tracker_;
+  std::shared_ptr<DHTMessageTracker> tracker_;
 
-  SharedHandle<DHTConnection> connection_;
+  std::shared_ptr<DHTConnection> connection_;
 
-  SharedHandle<DHTMessageFactory> factory_;
+  std::shared_ptr<DHTMessageFactory> factory_;
 
-  SharedHandle<DHTRoutingTable> routingTable_;
+  std::shared_ptr<DHTRoutingTable> routingTable_;
 
-  SharedHandle<DHTMessage>
+  std::shared_ptr<DHTMessage>
   handleUnknownMessage(const unsigned char* data, size_t length,
                        const std::string& remoteAddr, uint16_t remotePort);
 
-  void onMessageReceived(const SharedHandle<DHTMessage>& message);
+  void onMessageReceived(const std::shared_ptr<DHTMessage>& message);
 public:
-  DHTMessageReceiver(const SharedHandle<DHTMessageTracker>& tracker);
+  DHTMessageReceiver(const std::shared_ptr<DHTMessageTracker>& tracker);
 
   ~DHTMessageReceiver();
 
-  SharedHandle<DHTMessage> receiveMessage
+  std::shared_ptr<DHTMessage> receiveMessage
   (const std::string& remoteAddr, uint16_t remotePort, unsigned char *data,
    size_t length);
 
   void handleTimeout();
 
-  const SharedHandle<DHTConnection>& getConnection() const
+  const std::shared_ptr<DHTConnection>& getConnection() const
   {
     return connection_;
   }
 
-  const SharedHandle<DHTMessageTracker>& getMessageTracker() const
+  const std::shared_ptr<DHTMessageTracker>& getMessageTracker() const
   {
     return tracker_;
   }
 
-  void setConnection(const SharedHandle<DHTConnection>& connection);
+  void setConnection(const std::shared_ptr<DHTConnection>& connection);
 
-  void setMessageFactory(const SharedHandle<DHTMessageFactory>& factory);
+  void setMessageFactory(const std::shared_ptr<DHTMessageFactory>& factory);
 
-  void setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable);
+  void setRoutingTable(const std::shared_ptr<DHTRoutingTable>& routingTable);
 };
 
 } // namespace aria2
diff --git a/src/DHTMessageTracker.cc b/src/DHTMessageTracker.cc
index 06baf50e..261acdc3 100644
--- a/src/DHTMessageTracker.cc
+++ b/src/DHTMessageTracker.cc
@@ -55,13 +55,13 @@ DHTMessageTracker::DHTMessageTracker() {}
 
 DHTMessageTracker::~DHTMessageTracker() {}
 
-void DHTMessageTracker::addMessage(const SharedHandle<DHTMessage>& message, time_t timeout, const SharedHandle<DHTMessageCallback>& callback)
+void DHTMessageTracker::addMessage(const std::shared_ptr<DHTMessage>& message, time_t timeout, const std::shared_ptr<DHTMessageCallback>& callback)
 {
-  SharedHandle<DHTMessageTrackerEntry> e(new DHTMessageTrackerEntry(message, timeout, callback));
+  std::shared_ptr<DHTMessageTrackerEntry> e(new DHTMessageTrackerEntry(message, timeout, callback));
   entries_.push_back(e);
 }
 
-std::pair<SharedHandle<DHTResponseMessage>, SharedHandle<DHTMessageCallback> >
+std::pair<std::shared_ptr<DHTResponseMessage>, std::shared_ptr<DHTMessageCallback> >
 DHTMessageTracker::messageArrived
 (const Dict* dict, const std::string& ipaddr, uint16_t port)
 {
@@ -73,15 +73,15 @@ DHTMessageTracker::messageArrived
   A2_LOG_DEBUG(fmt("Searching tracker entry for TransactionID=%s, Remote=%s:%u",
                    util::toHex(tid->s()).c_str(),
                    ipaddr.c_str(), port));
-  for(std::deque<SharedHandle<DHTMessageTrackerEntry> >::iterator i =
+  for(std::deque<std::shared_ptr<DHTMessageTrackerEntry> >::iterator i =
         entries_.begin(), eoi = entries_.end(); i != eoi; ++i) {
     if((*i)->match(tid->s(), ipaddr, port)) {
-      SharedHandle<DHTMessageTrackerEntry> entry = *i;
+      std::shared_ptr<DHTMessageTrackerEntry> entry = *i;
       entries_.erase(i);
       A2_LOG_DEBUG("Tracker entry found.");
-      SharedHandle<DHTNode> targetNode = entry->getTargetNode();
+      std::shared_ptr<DHTNode> targetNode = entry->getTargetNode();
       try {
-        SharedHandle<DHTResponseMessage> message =
+        std::shared_ptr<DHTResponseMessage> message =
           factory_->createResponseMessage(entry->getMessageType(), dict,
                                           targetNode->getIPAddress(),
                                           targetNode->getPort());
@@ -89,7 +89,7 @@ DHTMessageTracker::messageArrived
         int64_t rtt = entry->getElapsedMillis();
         A2_LOG_DEBUG(fmt("RTT is %" PRId64 "", rtt));
         message->getRemoteNode()->updateRTT(rtt);
-        SharedHandle<DHTMessageCallback> callback = entry->getCallback();
+        std::shared_ptr<DHTMessageCallback> callback = entry->getCallback();
         if(!(*targetNode == *message->getRemoteNode())) {
           // Node ID has changed. Drop previous node ID from
           // DHTRoutingTable
@@ -108,15 +108,15 @@ DHTMessageTracker::messageArrived
     }
   }
   A2_LOG_DEBUG("Tracker entry not found.");
-  return std::pair<SharedHandle<DHTResponseMessage>,
-                   SharedHandle<DHTMessageCallback> >();
+  return std::pair<std::shared_ptr<DHTResponseMessage>,
+                   std::shared_ptr<DHTMessageCallback> >();
 }
 
 void DHTMessageTracker::handleTimeoutEntry
-(const SharedHandle<DHTMessageTrackerEntry>& entry)
+(const std::shared_ptr<DHTMessageTrackerEntry>& entry)
 {
   try {
-    SharedHandle<DHTNode> node = entry->getTargetNode();
+    std::shared_ptr<DHTNode> node = entry->getTargetNode();
     A2_LOG_DEBUG(fmt("Message timeout: To:%s:%u",
                      node->getIPAddress().c_str(), node->getPort()));
     node->updateRTT(entry->getElapsedMillis());
@@ -126,7 +126,7 @@ void DHTMessageTracker::handleTimeoutEntry
                        node->getIPAddress().c_str(), node->getPort()));
       routingTable_->dropNode(node);
     }
-    SharedHandle<DHTMessageCallback> callback = entry->getCallback();
+    std::shared_ptr<DHTMessageCallback> callback = entry->getCallback();
     if(callback) {
       callback->onTimeout(node);
     }
@@ -140,7 +140,7 @@ struct HandleTimeout {
   HandleTimeout(DHTMessageTracker* tracker)
   : tracker(tracker)
   {}
-  bool operator()(const SharedHandle<DHTMessageTrackerEntry>& ent) const
+  bool operator()(const std::shared_ptr<DHTMessageTrackerEntry>& ent) const
   {
     if(ent->isTimeout()) {
       tracker->handleTimeoutEntry(ent);
@@ -160,10 +160,10 @@ void DHTMessageTracker::handleTimeout()
                  entries_.end());
 }
 
-SharedHandle<DHTMessageTrackerEntry>
-DHTMessageTracker::getEntryFor(const SharedHandle<DHTMessage>& message) const
+std::shared_ptr<DHTMessageTrackerEntry>
+DHTMessageTracker::getEntryFor(const std::shared_ptr<DHTMessage>& message) const
 {
-  for(std::deque<SharedHandle<DHTMessageTrackerEntry> >::const_iterator i =
+  for(std::deque<std::shared_ptr<DHTMessageTrackerEntry> >::const_iterator i =
         entries_.begin(), eoi = entries_.end(); i != eoi; ++i) {
     if((*i)->match(message->getTransactionID(),
                    message->getRemoteNode()->getIPAddress(),
@@ -171,7 +171,7 @@ DHTMessageTracker::getEntryFor(const SharedHandle<DHTMessage>& message) const
       return *i;
     }
   }
-  return SharedHandle<DHTMessageTrackerEntry>();
+  return std::shared_ptr<DHTMessageTrackerEntry>();
 }
 
 size_t DHTMessageTracker::countEntry() const
@@ -180,13 +180,13 @@ size_t DHTMessageTracker::countEntry() const
 }
 
 void DHTMessageTracker::setRoutingTable
-(const SharedHandle<DHTRoutingTable>& routingTable)
+(const std::shared_ptr<DHTRoutingTable>& routingTable)
 {
   routingTable_ = routingTable;
 }
 
 void DHTMessageTracker::setMessageFactory
-(const SharedHandle<DHTMessageFactory>& factory)
+(const std::shared_ptr<DHTMessageFactory>& factory)
 {
   factory_ = factory;
 }
diff --git a/src/DHTMessageTracker.h b/src/DHTMessageTracker.h
index 39aa5d8f..5686ba4f 100644
--- a/src/DHTMessageTracker.h
+++ b/src/DHTMessageTracker.h
@@ -39,8 +39,8 @@
 
 #include <utility>
 #include <deque>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "a2time.h"
 #include "ValueBase.h"
 
@@ -55,38 +55,38 @@ class DHTMessageTrackerEntry;
 
 class DHTMessageTracker {
 private:
-  std::deque<SharedHandle<DHTMessageTrackerEntry> > entries_;
+  std::deque<std::shared_ptr<DHTMessageTrackerEntry> > entries_;
 
-  SharedHandle<DHTRoutingTable> routingTable_;
+  std::shared_ptr<DHTRoutingTable> routingTable_;
 
-  SharedHandle<DHTMessageFactory> factory_;
+  std::shared_ptr<DHTMessageFactory> factory_;
 public:
   DHTMessageTracker();
 
   ~DHTMessageTracker();
 
-  void addMessage(const SharedHandle<DHTMessage>& message,
+  void addMessage(const std::shared_ptr<DHTMessage>& message,
                   time_t timeout,
-                  const SharedHandle<DHTMessageCallback>& callback =
-                  SharedHandle<DHTMessageCallback>());
+                  const std::shared_ptr<DHTMessageCallback>& callback =
+                  std::shared_ptr<DHTMessageCallback>());
 
-  std::pair<SharedHandle<DHTResponseMessage>, SharedHandle<DHTMessageCallback> >
+  std::pair<std::shared_ptr<DHTResponseMessage>, std::shared_ptr<DHTMessageCallback> >
   messageArrived(const Dict* dict,
                  const std::string& ipaddr, uint16_t port);
 
   void handleTimeout();
 
   // Made public so that unnamed functor can access this
-  void handleTimeoutEntry(const SharedHandle<DHTMessageTrackerEntry>& entry);
+  void handleTimeoutEntry(const std::shared_ptr<DHTMessageTrackerEntry>& entry);
 
-  SharedHandle<DHTMessageTrackerEntry> getEntryFor
-  (const SharedHandle<DHTMessage>& message) const;
+  std::shared_ptr<DHTMessageTrackerEntry> getEntryFor
+  (const std::shared_ptr<DHTMessage>& message) const;
 
   size_t countEntry() const;
 
-  void setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable);
+  void setRoutingTable(const std::shared_ptr<DHTRoutingTable>& routingTable);
 
-  void setMessageFactory(const SharedHandle<DHTMessageFactory>& factory);
+  void setMessageFactory(const std::shared_ptr<DHTMessageFactory>& factory);
 };
 
 } // namespace aria2
diff --git a/src/DHTMessageTrackerEntry.cc b/src/DHTMessageTrackerEntry.cc
index 59ad4322..1b36ab6d 100644
--- a/src/DHTMessageTrackerEntry.cc
+++ b/src/DHTMessageTrackerEntry.cc
@@ -42,9 +42,9 @@
 
 namespace aria2 {
 
-DHTMessageTrackerEntry::DHTMessageTrackerEntry(const SharedHandle<DHTMessage>& sentMessage,
+DHTMessageTrackerEntry::DHTMessageTrackerEntry(const std::shared_ptr<DHTMessage>& sentMessage,
                                                time_t timeout,
-                                               const SharedHandle<DHTMessageCallback>& callback):
+                                               const std::shared_ptr<DHTMessageCallback>& callback):
   targetNode_(sentMessage->getRemoteNode()),
   transactionID_(sentMessage->getTransactionID()),
   messageType_(sentMessage->getMessageType()),
diff --git a/src/DHTMessageTrackerEntry.h b/src/DHTMessageTrackerEntry.h
index 7674e186..48dcef16 100644
--- a/src/DHTMessageTrackerEntry.h
+++ b/src/DHTMessageTrackerEntry.h
@@ -38,8 +38,8 @@
 #include "common.h"
 
 #include <string>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "DHTConstants.h"
 #include "TimerA2.h"
 
@@ -51,22 +51,22 @@ class DHTMessageCallback;
 
 class DHTMessageTrackerEntry {
 private:
-  SharedHandle<DHTNode> targetNode_;
+  std::shared_ptr<DHTNode> targetNode_;
 
   std::string transactionID_;
 
   std::string messageType_;
 
-  SharedHandle<DHTMessageCallback> callback_;
+  std::shared_ptr<DHTMessageCallback> callback_;
 
   Timer dispatchedTime_;
 
   time_t timeout_;
 public:
-  DHTMessageTrackerEntry(const SharedHandle<DHTMessage>& sentMessage,
+  DHTMessageTrackerEntry(const std::shared_ptr<DHTMessage>& sentMessage,
                          time_t timeout,
-                         const SharedHandle<DHTMessageCallback>& callback =
-                         SharedHandle<DHTMessageCallback>());
+                         const std::shared_ptr<DHTMessageCallback>& callback =
+                         std::shared_ptr<DHTMessageCallback>());
 
   ~DHTMessageTrackerEntry();
 
@@ -76,7 +76,7 @@ public:
 
   bool match(const std::string& transactionID, const std::string& ipaddr, uint16_t port) const;
 
-  const SharedHandle<DHTNode>& getTargetNode() const
+  const std::shared_ptr<DHTNode>& getTargetNode() const
   {
     return targetNode_;
   }
@@ -86,7 +86,7 @@ public:
     return messageType_;
   }
 
-  const SharedHandle<DHTMessageCallback>& getCallback() const
+  const std::shared_ptr<DHTMessageCallback>& getCallback() const
   {
     return callback_;
   }
diff --git a/src/DHTNode.h b/src/DHTNode.h
index 303b23c8..619ecc0b 100644
--- a/src/DHTNode.h
+++ b/src/DHTNode.h
@@ -39,7 +39,6 @@
 
 #include <string>
 
-#include "SharedHandle.h"
 #include "DHTConstants.h"
 #include "TimerA2.h"
 
diff --git a/src/DHTNodeLookupEntry.cc b/src/DHTNodeLookupEntry.cc
index 0026e4bf..82eda5da 100644
--- a/src/DHTNodeLookupEntry.cc
+++ b/src/DHTNodeLookupEntry.cc
@@ -37,7 +37,7 @@
 
 namespace aria2 {
 
-DHTNodeLookupEntry::DHTNodeLookupEntry(const SharedHandle<DHTNode>& node):
+DHTNodeLookupEntry::DHTNodeLookupEntry(const std::shared_ptr<DHTNode>& node):
   node(node), used(false) {}
 
 DHTNodeLookupEntry::DHTNodeLookupEntry():
diff --git a/src/DHTNodeLookupEntry.h b/src/DHTNodeLookupEntry.h
index 6a6016ae..6475381b 100644
--- a/src/DHTNodeLookupEntry.h
+++ b/src/DHTNodeLookupEntry.h
@@ -36,18 +36,19 @@
 #define D_DHT_NODE_LOOKUP_ENTRY_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
 class DHTNode;
 
 struct DHTNodeLookupEntry {
-  SharedHandle<DHTNode> node;
+  std::shared_ptr<DHTNode> node;
 
   bool used;
 
-  DHTNodeLookupEntry(const SharedHandle<DHTNode>& node);
+  DHTNodeLookupEntry(const std::shared_ptr<DHTNode>& node);
 
   DHTNodeLookupEntry();
 
diff --git a/src/DHTNodeLookupTask.cc b/src/DHTNodeLookupTask.cc
index 46c56c35..c116d403 100644
--- a/src/DHTNodeLookupTask.cc
+++ b/src/DHTNodeLookupTask.cc
@@ -50,23 +50,23 @@ DHTNodeLookupTask::DHTNodeLookupTask(const unsigned char* targetNodeID):
 
 void
 DHTNodeLookupTask::getNodesFromMessage
-(std::vector<SharedHandle<DHTNode> >& nodes,
+(std::vector<std::shared_ptr<DHTNode> >& nodes,
  const DHTFindNodeReplyMessage* message)
 {
-  const std::vector<SharedHandle<DHTNode> >& knodes =
+  const std::vector<std::shared_ptr<DHTNode> >& knodes =
     message->getClosestKNodes();
   nodes.insert(nodes.end(), knodes.begin(), knodes.end());
 }
 
-SharedHandle<DHTMessage>
-DHTNodeLookupTask::createMessage(const SharedHandle<DHTNode>& remoteNode)
+std::shared_ptr<DHTMessage>
+DHTNodeLookupTask::createMessage(const std::shared_ptr<DHTNode>& remoteNode)
 {
   return getMessageFactory()->createFindNodeMessage(remoteNode, getTargetID());
 }
 
-SharedHandle<DHTMessageCallback> DHTNodeLookupTask::createCallback()
+std::shared_ptr<DHTMessageCallback> DHTNodeLookupTask::createCallback()
 {
-  return SharedHandle<DHTNodeLookupTaskCallback>
+  return std::shared_ptr<DHTNodeLookupTaskCallback>
     (new DHTNodeLookupTaskCallback(this));
 }
 
diff --git a/src/DHTNodeLookupTask.h b/src/DHTNodeLookupTask.h
index b60b2715..f1fd11a8 100644
--- a/src/DHTNodeLookupTask.h
+++ b/src/DHTNodeLookupTask.h
@@ -47,13 +47,13 @@ public:
   DHTNodeLookupTask(const unsigned char* targetNodeID);
 
   virtual void getNodesFromMessage
-  (std::vector<SharedHandle<DHTNode> >& nodes,
+  (std::vector<std::shared_ptr<DHTNode> >& nodes,
    const DHTFindNodeReplyMessage* message);
 
-  virtual SharedHandle<DHTMessage> createMessage
-  (const SharedHandle<DHTNode>& remoteNode);
+  virtual std::shared_ptr<DHTMessage> createMessage
+  (const std::shared_ptr<DHTNode>& remoteNode);
 
-  virtual SharedHandle<DHTMessageCallback> createCallback();
+  virtual std::shared_ptr<DHTMessageCallback> createCallback();
 };
 
 } // namespace aria2
diff --git a/src/DHTNodeLookupTaskCallback.cc b/src/DHTNodeLookupTaskCallback.cc
index 59b60d6a..1a07a8c7 100644
--- a/src/DHTNodeLookupTaskCallback.cc
+++ b/src/DHTNodeLookupTaskCallback.cc
@@ -70,7 +70,7 @@ void DHTNodeLookupTaskCallback::visit(const DHTPingReplyMessage* message)
 }
 
 void DHTNodeLookupTaskCallback::onTimeout
-(const SharedHandle<DHTNode>& remoteNode)
+(const std::shared_ptr<DHTNode>& remoteNode)
 {
   task_->onTimeout(remoteNode);
 }
diff --git a/src/DHTNodeLookupTaskCallback.h b/src/DHTNodeLookupTaskCallback.h
index 33d3a3d1..441ddce7 100644
--- a/src/DHTNodeLookupTaskCallback.h
+++ b/src/DHTNodeLookupTaskCallback.h
@@ -55,7 +55,7 @@ public:
 
   virtual void visit(const DHTPingReplyMessage* message);
 
-  virtual void onTimeout(const SharedHandle<DHTNode>& remoteNode);
+  virtual void onTimeout(const std::shared_ptr<DHTNode>& remoteNode);
 };
 
 } // namespace aria2
diff --git a/src/DHTPeerAnnounceCommand.cc b/src/DHTPeerAnnounceCommand.cc
index 9ab386cf..97945c01 100644
--- a/src/DHTPeerAnnounceCommand.cc
+++ b/src/DHTPeerAnnounceCommand.cc
@@ -68,7 +68,7 @@ void DHTPeerAnnounceCommand::process()
 }
 
 void DHTPeerAnnounceCommand::setPeerAnnounceStorage
-(const SharedHandle<DHTPeerAnnounceStorage>& storage)
+(const std::shared_ptr<DHTPeerAnnounceStorage>& storage)
 {
   peerAnnounceStorage_ = storage;
 }
diff --git a/src/DHTPeerAnnounceCommand.h b/src/DHTPeerAnnounceCommand.h
index 4e313cf5..a704b8f8 100644
--- a/src/DHTPeerAnnounceCommand.h
+++ b/src/DHTPeerAnnounceCommand.h
@@ -36,7 +36,8 @@
 #define D_DHT_PEER_ANNOUNCE_COMMAND_H
 
 #include "TimeBasedCommand.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -44,7 +45,7 @@ class DHTPeerAnnounceStorage;
 
 class DHTPeerAnnounceCommand:public TimeBasedCommand {
 private:
-  SharedHandle<DHTPeerAnnounceStorage> peerAnnounceStorage_;
+  std::shared_ptr<DHTPeerAnnounceStorage> peerAnnounceStorage_;
 public:
   DHTPeerAnnounceCommand(cuid_t cuid, DownloadEngine* e, time_t interval);
 
@@ -54,7 +55,7 @@ public:
 
   virtual void process();
 
-  void setPeerAnnounceStorage(const SharedHandle<DHTPeerAnnounceStorage>& storage);
+  void setPeerAnnounceStorage(const std::shared_ptr<DHTPeerAnnounceStorage>& storage);
 };
 
 } // namespace aria2
diff --git a/src/DHTPeerAnnounceEntry.cc b/src/DHTPeerAnnounceEntry.cc
index 3fe0a470..bec96191 100644
--- a/src/DHTPeerAnnounceEntry.cc
+++ b/src/DHTPeerAnnounceEntry.cc
@@ -96,11 +96,11 @@ bool DHTPeerAnnounceEntry::empty() const
 }
 
 void DHTPeerAnnounceEntry::getPeers
-(std::vector<SharedHandle<Peer> >& peers) const
+(std::vector<std::shared_ptr<Peer> >& peers) const
 {
   for(std::vector<PeerAddrEntry>::const_iterator i = peerAddrEntries_.begin(),
         eoi = peerAddrEntries_.end(); i != eoi; ++i) {
-    SharedHandle<Peer> peer(new Peer((*i).getIPAddress(), (*i).getPort()));
+    std::shared_ptr<Peer> peer(new Peer((*i).getIPAddress(), (*i).getPort()));
     peers.push_back(peer);
   }
 }
diff --git a/src/DHTPeerAnnounceEntry.h b/src/DHTPeerAnnounceEntry.h
index 427720ab..b1d29b8c 100644
--- a/src/DHTPeerAnnounceEntry.h
+++ b/src/DHTPeerAnnounceEntry.h
@@ -38,8 +38,8 @@
 #include "common.h"
 
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "DHTConstants.h"
 #include "PeerAddrEntry.h"
 #include "TimerA2.h"
@@ -87,7 +87,7 @@ public:
     return infoHash_;
   }
 
-  void getPeers(std::vector<SharedHandle<Peer> >& peers) const;
+  void getPeers(std::vector<std::shared_ptr<Peer> >& peers) const;
 
 };
 
diff --git a/src/DHTPeerAnnounceStorage.cc b/src/DHTPeerAnnounceStorage.cc
index 3a7cee9c..11f38a80 100644
--- a/src/DHTPeerAnnounceStorage.cc
+++ b/src/DHTPeerAnnounceStorage.cc
@@ -57,16 +57,16 @@ DHTPeerAnnounceStorage::DHTPeerAnnounceStorage() {}
 DHTPeerAnnounceStorage::~DHTPeerAnnounceStorage() {}
 
 bool DHTPeerAnnounceStorage::InfoHashLess::operator()
-  (const SharedHandle<DHTPeerAnnounceEntry>& lhs,
-   const SharedHandle<DHTPeerAnnounceEntry>& rhs)
+  (const std::shared_ptr<DHTPeerAnnounceEntry>& lhs,
+   const std::shared_ptr<DHTPeerAnnounceEntry>& rhs)
 {
   return memcmp(lhs->getInfoHash(), rhs->getInfoHash(), DHT_ID_LENGTH) < 0;
 }
 
-SharedHandle<DHTPeerAnnounceEntry>
+std::shared_ptr<DHTPeerAnnounceEntry>
 DHTPeerAnnounceStorage::getPeerAnnounceEntry(const unsigned char* infoHash)
 {
-  SharedHandle<DHTPeerAnnounceEntry> entry(new DHTPeerAnnounceEntry(infoHash));
+  std::shared_ptr<DHTPeerAnnounceEntry> entry(new DHTPeerAnnounceEntry(infoHash));
 
   DHTPeerAnnounceEntrySet::iterator i = entries_.lower_bound(entry);
 
@@ -91,15 +91,15 @@ DHTPeerAnnounceStorage::addPeerAnnounce(const unsigned char* infoHash,
 
 bool DHTPeerAnnounceStorage::contains(const unsigned char* infoHash) const
 {
-  SharedHandle<DHTPeerAnnounceEntry> entry(new DHTPeerAnnounceEntry(infoHash));
+  std::shared_ptr<DHTPeerAnnounceEntry> entry(new DHTPeerAnnounceEntry(infoHash));
   return
     std::binary_search(entries_.begin(), entries_.end(), entry, InfoHashLess());
 }
 
-void DHTPeerAnnounceStorage::getPeers(std::vector<SharedHandle<Peer> >& peers,
+void DHTPeerAnnounceStorage::getPeers(std::vector<std::shared_ptr<Peer> >& peers,
                                       const unsigned char* infoHash)
 {
-  SharedHandle<DHTPeerAnnounceEntry> entry(new DHTPeerAnnounceEntry(infoHash));
+  std::shared_ptr<DHTPeerAnnounceEntry> entry(new DHTPeerAnnounceEntry(infoHash));
 
   DHTPeerAnnounceEntrySet::iterator i = entries_.find(entry);
   if(i != entries_.end()) {
@@ -111,7 +111,7 @@ namespace {
 class RemoveStalePeerAddrEntry
 {
 public:
-  void operator()(const SharedHandle<DHTPeerAnnounceEntry>& e)
+  void operator()(const std::shared_ptr<DHTPeerAnnounceEntry>& e)
   {
     e->removeStalePeerAddrEntry(DHT_PEER_ANNOUNCE_PURGE_INTERVAL);
   }
@@ -143,7 +143,7 @@ void DHTPeerAnnounceStorage::announcePeer()
     if((*i)->getLastUpdated().
        difference(global::wallclock()) >= DHT_PEER_ANNOUNCE_INTERVAL) {
       (*i)->notifyUpdate();
-      SharedHandle<DHTTask> task =
+      std::shared_ptr<DHTTask> task =
         taskFactory_->createPeerAnnounceTask((*i)->getInfoHash());
       taskQueue_->addPeriodicTask2(task);
       A2_LOG_DEBUG
@@ -153,12 +153,12 @@ void DHTPeerAnnounceStorage::announcePeer()
   }
 }
 
-void DHTPeerAnnounceStorage::setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue)
+void DHTPeerAnnounceStorage::setTaskQueue(const std::shared_ptr<DHTTaskQueue>& taskQueue)
 {
   taskQueue_ = taskQueue;
 }
 
-void DHTPeerAnnounceStorage::setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory)
+void DHTPeerAnnounceStorage::setTaskFactory(const std::shared_ptr<DHTTaskFactory>& taskFactory)
 {
   taskFactory_ = taskFactory;
 }
diff --git a/src/DHTPeerAnnounceStorage.h b/src/DHTPeerAnnounceStorage.h
index e32ab7f2..a0f2dd22 100644
--- a/src/DHTPeerAnnounceStorage.h
+++ b/src/DHTPeerAnnounceStorage.h
@@ -40,8 +40,7 @@
 #include <set>
 #include <vector>
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -54,18 +53,18 @@ class DHTPeerAnnounceStorage {
 private:
   class InfoHashLess {
   public:
-    bool operator()(const SharedHandle<DHTPeerAnnounceEntry>& lhs,
-                    const SharedHandle<DHTPeerAnnounceEntry>& rhs);
+    bool operator()(const std::shared_ptr<DHTPeerAnnounceEntry>& lhs,
+                    const std::shared_ptr<DHTPeerAnnounceEntry>& rhs);
   };
-  typedef std::set<SharedHandle<DHTPeerAnnounceEntry>, InfoHashLess>
+  typedef std::set<std::shared_ptr<DHTPeerAnnounceEntry>, InfoHashLess>
   DHTPeerAnnounceEntrySet;
   DHTPeerAnnounceEntrySet entries_;
 
-  SharedHandle<DHTPeerAnnounceEntry> getPeerAnnounceEntry(const unsigned char* infoHash);
+  std::shared_ptr<DHTPeerAnnounceEntry> getPeerAnnounceEntry(const unsigned char* infoHash);
 
-  SharedHandle<DHTTaskQueue> taskQueue_;
+  std::shared_ptr<DHTTaskQueue> taskQueue_;
 
-  SharedHandle<DHTTaskFactory> taskFactory_;
+  std::shared_ptr<DHTTaskFactory> taskFactory_;
 public:
   DHTPeerAnnounceStorage();
 
@@ -76,7 +75,7 @@ public:
 
   bool contains(const unsigned char* infoHash) const;
 
-  void getPeers(std::vector<SharedHandle<Peer> >& peers,
+  void getPeers(std::vector<std::shared_ptr<Peer> >& peers,
                 const unsigned char* infoHash);
 
   // drop peer announce entry which is not updated in the past
@@ -88,9 +87,9 @@ public:
   // are excluded from announce.
   void announcePeer();
 
-  void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);
+  void setTaskQueue(const std::shared_ptr<DHTTaskQueue>& taskQueue);
 
-  void setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory);
+  void setTaskFactory(const std::shared_ptr<DHTTaskFactory>& taskFactory);
 };
 
 } // namespace aria2
diff --git a/src/DHTPeerLookupTask.cc b/src/DHTPeerLookupTask.cc
index 3c0b9eaa..9a9711d4 100644
--- a/src/DHTPeerLookupTask.cc
+++ b/src/DHTPeerLookupTask.cc
@@ -53,7 +53,7 @@
 namespace aria2 {
 
 DHTPeerLookupTask::DHTPeerLookupTask
-(const SharedHandle<DownloadContext>& downloadContext,
+(const std::shared_ptr<DownloadContext>& downloadContext,
  uint16_t tcpPort)
   : DHTAbstractNodeLookupTask<DHTGetPeersReplyMessage>
     (bittorrent::getInfoHash(downloadContext)),
@@ -62,10 +62,10 @@ DHTPeerLookupTask::DHTPeerLookupTask
 
 void
 DHTPeerLookupTask::getNodesFromMessage
-(std::vector<SharedHandle<DHTNode> >& nodes,
+(std::vector<std::shared_ptr<DHTNode> >& nodes,
  const DHTGetPeersReplyMessage* message)
 {
-  const std::vector<SharedHandle<DHTNode> >& knodes =
+  const std::vector<std::shared_ptr<DHTNode> >& knodes =
     message->getClosestKNodes();
   nodes.insert(nodes.end(), knodes.begin(), knodes.end());
 }
@@ -73,7 +73,7 @@ DHTPeerLookupTask::getNodesFromMessage
 void DHTPeerLookupTask::onReceivedInternal
 (const DHTGetPeersReplyMessage* message)
 {
-  SharedHandle<DHTNode> remoteNode = message->getRemoteNode();
+  std::shared_ptr<DHTNode> remoteNode = message->getRemoteNode();
   tokenStorage_[util::toHex(remoteNode->getID(), DHT_ID_LENGTH)] =
     message->getToken();
   peerStorage_->addPeer(message->getValues());
@@ -81,15 +81,15 @@ void DHTPeerLookupTask::onReceivedInternal
                   static_cast<unsigned long>(message->getValues().size())));
 }
 
-SharedHandle<DHTMessage> DHTPeerLookupTask::createMessage
-(const SharedHandle<DHTNode>& remoteNode)
+std::shared_ptr<DHTMessage> DHTPeerLookupTask::createMessage
+(const std::shared_ptr<DHTNode>& remoteNode)
 {
   return getMessageFactory()->createGetPeersMessage(remoteNode, getTargetID());
 }
 
-SharedHandle<DHTMessageCallback> DHTPeerLookupTask::createCallback()
+std::shared_ptr<DHTMessageCallback> DHTPeerLookupTask::createCallback()
 {
-  return SharedHandle<DHTPeerLookupTaskCallback>
+  return std::shared_ptr<DHTPeerLookupTaskCallback>
     (new DHTPeerLookupTaskCallback(this));
 }
 
@@ -99,20 +99,20 @@ void DHTPeerLookupTask::onFinish()
                    util::toHex(getTargetID(), DHT_ID_LENGTH).c_str()));
   // send announce_peer message to K closest nodes
   size_t num = DHTBucket::K;
-  for(std::deque<SharedHandle<DHTNodeLookupEntry> >::const_iterator i =
+  for(std::deque<std::shared_ptr<DHTNodeLookupEntry> >::const_iterator i =
         getEntries().begin(), eoi = getEntries().end();
       i != eoi && num > 0; ++i) {
     if(!(*i)->used) {
       continue;
     }
-    const SharedHandle<DHTNode>& node = (*i)->node;
+    const std::shared_ptr<DHTNode>& node = (*i)->node;
     std::string idHex = util::toHex(node->getID(), DHT_ID_LENGTH);
     std::string token = tokenStorage_[idHex];
     if(token.empty()) {
       A2_LOG_DEBUG(fmt("Token is empty for ID:%s", idHex.c_str()));
       continue;
     }
-    SharedHandle<DHTMessage> m =
+    std::shared_ptr<DHTMessage> m =
       getMessageFactory()->createAnnouncePeerMessage
       (node,
        getTargetID(), // this is infoHash
@@ -123,7 +123,7 @@ void DHTPeerLookupTask::onFinish()
   }
 }
 
-void DHTPeerLookupTask::setPeerStorage(const SharedHandle<PeerStorage>& ps)
+void DHTPeerLookupTask::setPeerStorage(const std::shared_ptr<PeerStorage>& ps)
 {
   peerStorage_ = ps;
 }
diff --git a/src/DHTPeerLookupTask.h b/src/DHTPeerLookupTask.h
index 1f444878..7b269dff 100644
--- a/src/DHTPeerLookupTask.h
+++ b/src/DHTPeerLookupTask.h
@@ -50,27 +50,27 @@ class DHTPeerLookupTask:
 private:
   std::map<std::string, std::string> tokenStorage_;
 
-  SharedHandle<PeerStorage> peerStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
   uint16_t tcpPort_;
 public:
   DHTPeerLookupTask
-  (const SharedHandle<DownloadContext>& downloadContext,
+  (const std::shared_ptr<DownloadContext>& downloadContext,
    uint16_t tcpPort);
 
   virtual void getNodesFromMessage
-  (std::vector<SharedHandle<DHTNode> >& nodes,
+  (std::vector<std::shared_ptr<DHTNode> >& nodes,
    const DHTGetPeersReplyMessage* message);
 
   virtual void onReceivedInternal(const DHTGetPeersReplyMessage* message);
 
-  virtual SharedHandle<DHTMessage> createMessage
-  (const SharedHandle<DHTNode>& remoteNode);
+  virtual std::shared_ptr<DHTMessage> createMessage
+  (const std::shared_ptr<DHTNode>& remoteNode);
 
-  virtual SharedHandle<DHTMessageCallback> createCallback();
+  virtual std::shared_ptr<DHTMessageCallback> createCallback();
 
   virtual void onFinish();
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 };
 
 } // namespace aria2
diff --git a/src/DHTPeerLookupTaskCallback.cc b/src/DHTPeerLookupTaskCallback.cc
index dc60a45e..de0fa875 100644
--- a/src/DHTPeerLookupTaskCallback.cc
+++ b/src/DHTPeerLookupTaskCallback.cc
@@ -67,7 +67,7 @@ void DHTPeerLookupTaskCallback::visit(const DHTPingReplyMessage* message)
 }
 
 void DHTPeerLookupTaskCallback::onTimeout
-(const SharedHandle<DHTNode>& remoteNode)
+(const std::shared_ptr<DHTNode>& remoteNode)
 {
   task_->onTimeout(remoteNode);
 }
diff --git a/src/DHTPeerLookupTaskCallback.h b/src/DHTPeerLookupTaskCallback.h
index efdc1f14..78cdc924 100644
--- a/src/DHTPeerLookupTaskCallback.h
+++ b/src/DHTPeerLookupTaskCallback.h
@@ -55,7 +55,7 @@ public:
 
   virtual void visit(const DHTPingReplyMessage* message);
 
-  virtual void onTimeout(const SharedHandle<DHTNode>& remoteNode);
+  virtual void onTimeout(const std::shared_ptr<DHTNode>& remoteNode);
 };
 
 } // namespace aria2
diff --git a/src/DHTPingMessage.cc b/src/DHTPingMessage.cc
index 6038aab3..7ef680be 100644
--- a/src/DHTPingMessage.cc
+++ b/src/DHTPingMessage.cc
@@ -43,8 +43,8 @@ namespace aria2 {
 
 const std::string DHTPingMessage::PING("ping");
 
-DHTPingMessage::DHTPingMessage(const SharedHandle<DHTNode>& localNode,
-                               const SharedHandle<DHTNode>& remoteNode,
+DHTPingMessage::DHTPingMessage(const std::shared_ptr<DHTNode>& localNode,
+                               const std::shared_ptr<DHTNode>& remoteNode,
                                const std::string& transactionID):
   DHTQueryMessage(localNode, remoteNode, transactionID) {}
 
@@ -53,15 +53,15 @@ DHTPingMessage::~DHTPingMessage() {}
 void DHTPingMessage::doReceivedAction()
 {
   // send back ping reply
-  SharedHandle<DHTMessage> reply =
+  std::shared_ptr<DHTMessage> reply =
     getMessageFactory()->createPingReplyMessage
     (getRemoteNode(), getLocalNode()->getID(), getTransactionID());
   getMessageDispatcher()->addMessageToQueue(reply);
 }
 
-SharedHandle<Dict> DHTPingMessage::getArgument()
+std::shared_ptr<Dict> DHTPingMessage::getArgument()
 {
-  SharedHandle<Dict> aDict = Dict::g();
+  std::shared_ptr<Dict> aDict = Dict::g();
   aDict->put(DHTMessage::ID, String::g(getLocalNode()->getID(), DHT_ID_LENGTH));
   return aDict;
 }
diff --git a/src/DHTPingMessage.h b/src/DHTPingMessage.h
index fc265c23..d626d212 100644
--- a/src/DHTPingMessage.h
+++ b/src/DHTPingMessage.h
@@ -42,15 +42,15 @@ namespace aria2 {
 
 class DHTPingMessage:public DHTQueryMessage {
 public:
-  DHTPingMessage(const SharedHandle<DHTNode>& localNode,
-                 const SharedHandle<DHTNode>& remoteNode,
+  DHTPingMessage(const std::shared_ptr<DHTNode>& localNode,
+                 const std::shared_ptr<DHTNode>& remoteNode,
                  const std::string& transactionID = A2STR::NIL);
 
   virtual ~DHTPingMessage();
 
   virtual void doReceivedAction();
 
-  virtual SharedHandle<Dict> getArgument();
+  virtual std::shared_ptr<Dict> getArgument();
 
   virtual const std::string& getMessageType() const;
 
diff --git a/src/DHTPingReplyMessage.cc b/src/DHTPingReplyMessage.cc
index d0a89b58..9f050616 100644
--- a/src/DHTPingReplyMessage.cc
+++ b/src/DHTPingReplyMessage.cc
@@ -44,8 +44,8 @@ namespace aria2 {
 const std::string DHTPingReplyMessage::PING("ping");
 
 DHTPingReplyMessage::DHTPingReplyMessage
-(const SharedHandle<DHTNode>& localNode,
- const SharedHandle<DHTNode>& remoteNode,
+(const std::shared_ptr<DHTNode>& localNode,
+ const std::shared_ptr<DHTNode>& remoteNode,
  const unsigned char* id,
  const std::string& transactionID):
   DHTResponseMessage(localNode, remoteNode, transactionID)
@@ -57,9 +57,9 @@ DHTPingReplyMessage::~DHTPingReplyMessage() {}
 
 void DHTPingReplyMessage::doReceivedAction() {}
 
-SharedHandle<Dict> DHTPingReplyMessage::getResponse()
+std::shared_ptr<Dict> DHTPingReplyMessage::getResponse()
 {
-  SharedHandle<Dict> rDict = Dict::g();
+  std::shared_ptr<Dict> rDict = Dict::g();
   rDict->put(DHTMessage::ID, String::g(id_, DHT_ID_LENGTH));
   return rDict;
 }
diff --git a/src/DHTPingReplyMessage.h b/src/DHTPingReplyMessage.h
index 25771906..c300b225 100644
--- a/src/DHTPingReplyMessage.h
+++ b/src/DHTPingReplyMessage.h
@@ -44,8 +44,8 @@ class DHTPingReplyMessage:public DHTResponseMessage {
 private:
   unsigned char id_[DHT_ID_LENGTH];
 public:
-  DHTPingReplyMessage(const SharedHandle<DHTNode>& localNode,
-                      const SharedHandle<DHTNode>& remoteNode,
+  DHTPingReplyMessage(const std::shared_ptr<DHTNode>& localNode,
+                      const std::shared_ptr<DHTNode>& remoteNode,
                       const unsigned char* id,
                       const std::string& transactionID);
 
@@ -53,7 +53,7 @@ public:
 
   virtual void doReceivedAction();
 
-  virtual SharedHandle<Dict> getResponse();
+  virtual std::shared_ptr<Dict> getResponse();
 
   virtual const std::string& getMessageType() const;
 
diff --git a/src/DHTPingReplyMessageCallback.h b/src/DHTPingReplyMessageCallback.h
index 1743713b..ddb311f3 100644
--- a/src/DHTPingReplyMessageCallback.h
+++ b/src/DHTPingReplyMessageCallback.h
@@ -70,7 +70,7 @@ public:
     task_->onReceived(message);
   }
 
-  virtual void onTimeout(const SharedHandle<DHTNode>& remoteNode)
+  virtual void onTimeout(const std::shared_ptr<DHTNode>& remoteNode)
   {
     task_->onTimeout(remoteNode);
   }
diff --git a/src/DHTPingTask.cc b/src/DHTPingTask.cc
index 75a8e3b4..f0aaed64 100644
--- a/src/DHTPingTask.cc
+++ b/src/DHTPingTask.cc
@@ -44,7 +44,7 @@
 namespace aria2 {
 
 DHTPingTask::DHTPingTask
-(const SharedHandle<DHTNode>& remoteNode, int numMaxRetry):
+(const std::shared_ptr<DHTNode>& remoteNode, int numMaxRetry):
   remoteNode_(remoteNode),
   numMaxRetry_(numMaxRetry),
   numRetry_(0),
@@ -56,9 +56,9 @@ DHTPingTask::~DHTPingTask() {}
 
 void DHTPingTask::addMessage()
 {
-  SharedHandle<DHTMessage> m =
+  std::shared_ptr<DHTMessage> m =
     getMessageFactory()->createPingMessage(remoteNode_);
-  SharedHandle<DHTMessageCallback> callback
+  std::shared_ptr<DHTMessageCallback> callback
     (new DHTPingReplyMessageCallback<DHTPingTask>(this));
   getMessageDispatcher()->addMessageToQueue(m, timeout_, callback);
 }
@@ -74,7 +74,7 @@ void DHTPingTask::onReceived(const DHTPingReplyMessage* message)
   setFinished(true);
 }
 
-void DHTPingTask::onTimeout(const SharedHandle<DHTNode>& node)
+void DHTPingTask::onTimeout(const std::shared_ptr<DHTNode>& node)
 {
   ++numRetry_;
   if(numRetry_ >= numMaxRetry_) {
diff --git a/src/DHTPingTask.h b/src/DHTPingTask.h
index 85681fbf..db20b3c1 100644
--- a/src/DHTPingTask.h
+++ b/src/DHTPingTask.h
@@ -44,7 +44,7 @@ class DHTPingReplyMessage;
 
 class DHTPingTask:public DHTAbstractTask {
 private:
-  SharedHandle<DHTNode> remoteNode_;
+  std::shared_ptr<DHTNode> remoteNode_;
 
   int numMaxRetry_;
 
@@ -56,7 +56,7 @@ private:
 
   void addMessage();
 public:
-  DHTPingTask(const SharedHandle<DHTNode>& remoteNode, int numMaxRetry = 0);
+  DHTPingTask(const std::shared_ptr<DHTNode>& remoteNode, int numMaxRetry = 0);
 
   virtual ~DHTPingTask();
 
@@ -64,7 +64,7 @@ public:
 
   void onReceived(const DHTPingReplyMessage* message);
 
-  void onTimeout(const SharedHandle<DHTNode>& node);
+  void onTimeout(const std::shared_ptr<DHTNode>& node);
 
   void setTimeout(time_t timeout)
   {
diff --git a/src/DHTQueryMessage.cc b/src/DHTQueryMessage.cc
index 308f7df0..e3c85e1f 100644
--- a/src/DHTQueryMessage.cc
+++ b/src/DHTQueryMessage.cc
@@ -43,8 +43,8 @@ const std::string DHTQueryMessage::Q("q");
 
 const std::string DHTQueryMessage::A("a");
 
-DHTQueryMessage::DHTQueryMessage(const SharedHandle<DHTNode>& localNode,
-                                 const SharedHandle<DHTNode>& remoteNode,
+DHTQueryMessage::DHTQueryMessage(const std::shared_ptr<DHTNode>& localNode,
+                                 const std::shared_ptr<DHTNode>& remoteNode,
                                  const std::string& transactionID):
   DHTAbstractMessage(localNode, remoteNode, transactionID) {}
 
diff --git a/src/DHTQueryMessage.h b/src/DHTQueryMessage.h
index 295c2992..68996e91 100644
--- a/src/DHTQueryMessage.h
+++ b/src/DHTQueryMessage.h
@@ -45,8 +45,8 @@ class DHTQueryMessage:public DHTAbstractMessage {
 protected:
   virtual std::string toStringOptional() const { return A2STR::NIL; }
 public:
-  DHTQueryMessage(const SharedHandle<DHTNode>& localNode,
-                  const SharedHandle<DHTNode>& remoteNode,
+  DHTQueryMessage(const std::shared_ptr<DHTNode>& localNode,
+                  const std::shared_ptr<DHTNode>& remoteNode,
                   const std::string& transactionID = A2STR::NIL);
 
   virtual ~DHTQueryMessage();
@@ -55,7 +55,7 @@ public:
 
   virtual void fillMessage(Dict* msgDict);
 
-  virtual SharedHandle<Dict> getArgument() = 0;
+  virtual std::shared_ptr<Dict> getArgument() = 0;
 
   virtual bool isReply() const;
 
diff --git a/src/DHTRegistry.h b/src/DHTRegistry.h
index df79d28d..b8886844 100644
--- a/src/DHTRegistry.h
+++ b/src/DHTRegistry.h
@@ -36,7 +36,8 @@
 #define D_DHT_REGISTRY_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -55,23 +56,23 @@ private:
   struct Data {
     bool initialized;
 
-    SharedHandle<DHTNode> localNode;
+    std::shared_ptr<DHTNode> localNode;
 
-    SharedHandle<DHTRoutingTable> routingTable;
+    std::shared_ptr<DHTRoutingTable> routingTable;
 
-    SharedHandle<DHTTaskQueue> taskQueue;
+    std::shared_ptr<DHTTaskQueue> taskQueue;
 
-    SharedHandle<DHTTaskFactory> taskFactory;
+    std::shared_ptr<DHTTaskFactory> taskFactory;
 
-    SharedHandle<DHTPeerAnnounceStorage> peerAnnounceStorage;
+    std::shared_ptr<DHTPeerAnnounceStorage> peerAnnounceStorage;
 
-    SharedHandle<DHTTokenTracker> tokenTracker;
+    std::shared_ptr<DHTTokenTracker> tokenTracker;
 
-    SharedHandle<DHTMessageDispatcher> messageDispatcher;
+    std::shared_ptr<DHTMessageDispatcher> messageDispatcher;
 
-    SharedHandle<DHTMessageReceiver> messageReceiver;
+    std::shared_ptr<DHTMessageReceiver> messageReceiver;
 
-    SharedHandle<DHTMessageFactory> messageFactory;
+    std::shared_ptr<DHTMessageFactory> messageFactory;
 
     Data():initialized(false) {}
   };
diff --git a/src/DHTReplaceNodeTask.cc b/src/DHTReplaceNodeTask.cc
index 163102b0..fbf9a961 100644
--- a/src/DHTReplaceNodeTask.cc
+++ b/src/DHTReplaceNodeTask.cc
@@ -47,7 +47,7 @@
 namespace aria2 {
 
 DHTReplaceNodeTask::DHTReplaceNodeTask
-(const SharedHandle<DHTBucket>& bucket, const SharedHandle<DHTNode>& newNode)
+(const std::shared_ptr<DHTBucket>& bucket, const std::shared_ptr<DHTNode>& newNode)
   : bucket_(bucket),
     newNode_(newNode),
     numRetry_(0),
@@ -63,13 +63,13 @@ void DHTReplaceNodeTask::startup()
 
 void DHTReplaceNodeTask::sendMessage()
 {
-  SharedHandle<DHTNode> questionableNode = bucket_->getLRUQuestionableNode();
+  std::shared_ptr<DHTNode> questionableNode = bucket_->getLRUQuestionableNode();
   if(!questionableNode) {
     setFinished(true);
   } else {
-    SharedHandle<DHTMessage> m =
+    std::shared_ptr<DHTMessage> m =
       getMessageFactory()->createPingMessage(questionableNode);
-    SharedHandle<DHTMessageCallback> callback
+    std::shared_ptr<DHTMessageCallback> callback
       (new DHTPingReplyMessageCallback<DHTReplaceNodeTask>(this));
     getMessageDispatcher()->addMessageToQueue(m, timeout_, callback);
   }
@@ -86,7 +86,7 @@ namespace {
 const int MAX_RETRY = 2;
 } //namespace
 
-void DHTReplaceNodeTask::onTimeout(const SharedHandle<DHTNode>& node)
+void DHTReplaceNodeTask::onTimeout(const std::shared_ptr<DHTNode>& node)
 {
   ++numRetry_;
   if(numRetry_ >= MAX_RETRY) {
diff --git a/src/DHTReplaceNodeTask.h b/src/DHTReplaceNodeTask.h
index 005696e4..f934bd1e 100644
--- a/src/DHTReplaceNodeTask.h
+++ b/src/DHTReplaceNodeTask.h
@@ -45,9 +45,9 @@ class DHTPingReplyMessage;
 
 class DHTReplaceNodeTask:public DHTAbstractTask {
 private:
-  SharedHandle<DHTBucket> bucket_;
+  std::shared_ptr<DHTBucket> bucket_;
 
-  SharedHandle<DHTNode> newNode_;
+  std::shared_ptr<DHTNode> newNode_;
 
   int numRetry_;
 
@@ -55,8 +55,8 @@ private:
 
   void sendMessage();
 public:
-  DHTReplaceNodeTask(const SharedHandle<DHTBucket>& bucket,
-                     const SharedHandle<DHTNode>& newNode);
+  DHTReplaceNodeTask(const std::shared_ptr<DHTBucket>& bucket,
+                     const std::shared_ptr<DHTNode>& newNode);
 
   virtual ~DHTReplaceNodeTask();
 
@@ -64,7 +64,7 @@ public:
 
   void onReceived(const DHTPingReplyMessage* message);
 
-  void onTimeout(const SharedHandle<DHTNode>& node);
+  void onTimeout(const std::shared_ptr<DHTNode>& node);
 
   void setTimeout(time_t timeout)
   {
diff --git a/src/DHTResponseMessage.cc b/src/DHTResponseMessage.cc
index 952188f8..d2882131 100644
--- a/src/DHTResponseMessage.cc
+++ b/src/DHTResponseMessage.cc
@@ -41,8 +41,8 @@ namespace aria2 {
 
 const std::string DHTResponseMessage::R("r");
 
-DHTResponseMessage::DHTResponseMessage(const SharedHandle<DHTNode>& localNode,
-                                       const SharedHandle<DHTNode>& remoteNode,
+DHTResponseMessage::DHTResponseMessage(const std::shared_ptr<DHTNode>& localNode,
+                                       const std::shared_ptr<DHTNode>& remoteNode,
                                        const std::string& transactionID):
   DHTAbstractMessage(localNode, remoteNode, transactionID) {}
 
diff --git a/src/DHTResponseMessage.h b/src/DHTResponseMessage.h
index 68eef0f8..f5bbe937 100644
--- a/src/DHTResponseMessage.h
+++ b/src/DHTResponseMessage.h
@@ -47,8 +47,8 @@ class DHTResponseMessage:public DHTAbstractMessage {
 protected:
   virtual std::string toStringOptional() const { return A2STR::NIL; }
 public:
-  DHTResponseMessage(const SharedHandle<DHTNode>& localNode,
-                     const SharedHandle<DHTNode>& remoteNode,
+  DHTResponseMessage(const std::shared_ptr<DHTNode>& localNode,
+                     const std::shared_ptr<DHTNode>& remoteNode,
                      const std::string& transactionID);
 
   virtual ~DHTResponseMessage();
@@ -57,7 +57,7 @@ public:
 
   virtual void fillMessage(Dict* msgDict);
 
-  virtual SharedHandle<Dict> getResponse() = 0;
+  virtual std::shared_ptr<Dict> getResponse() = 0;
 
   virtual bool isReply() const;
 
diff --git a/src/DHTRoutingTable.cc b/src/DHTRoutingTable.cc
index ab23a7bb..24c91195 100644
--- a/src/DHTRoutingTable.cc
+++ b/src/DHTRoutingTable.cc
@@ -49,10 +49,10 @@
 
 namespace aria2 {
 
-DHTRoutingTable::DHTRoutingTable(const SharedHandle<DHTNode>& localNode)
+DHTRoutingTable::DHTRoutingTable(const std::shared_ptr<DHTNode>& localNode)
   : localNode_(localNode),
     root_(new DHTBucketTreeNode
-          (SharedHandle<DHTBucket>(new DHTBucket(localNode_)))),
+          (std::shared_ptr<DHTBucket>(new DHTBucket(localNode_)))),
     numBucket_(1)
 {}
 
@@ -61,17 +61,17 @@ DHTRoutingTable::~DHTRoutingTable()
   delete root_;
 }
 
-bool DHTRoutingTable::addNode(const SharedHandle<DHTNode>& node)
+bool DHTRoutingTable::addNode(const std::shared_ptr<DHTNode>& node)
 {
   return addNode(node, false);
 }
 
-bool DHTRoutingTable::addGoodNode(const SharedHandle<DHTNode>& node)
+bool DHTRoutingTable::addGoodNode(const std::shared_ptr<DHTNode>& node)
 {
   return addNode(node, true);
 }
 
-bool DHTRoutingTable::addNode(const SharedHandle<DHTNode>& node, bool good)
+bool DHTRoutingTable::addNode(const std::shared_ptr<DHTNode>& node, bool good)
 {
   A2_LOG_DEBUG(fmt("Trying to add node:%s", node->toString().c_str()));
   if(*localNode_ == *node) {
@@ -80,7 +80,7 @@ bool DHTRoutingTable::addNode(const SharedHandle<DHTNode>& node, bool good)
   }
   DHTBucketTreeNode* treeNode = dht::findTreeNodeFor(root_, node->getID());
   while(1) {
-    const SharedHandle<DHTBucket>& bucket = treeNode->getBucket();
+    const std::shared_ptr<DHTBucket>& bucket = treeNode->getBucket();
     if(bucket->addNode(node)) {
       A2_LOG_DEBUG("Added DHTNode.");
       return true;
@@ -107,7 +107,7 @@ bool DHTRoutingTable::addNode(const SharedHandle<DHTNode>& node, bool good)
 }
 
 void DHTRoutingTable::getClosestKNodes
-(std::vector<SharedHandle<DHTNode> >& nodes,
+(std::vector<std::shared_ptr<DHTNode> >& nodes,
  const unsigned char* key) const
 {
   dht::findClosestKNodes(nodes, root_, key);
@@ -120,56 +120,56 @@ int DHTRoutingTable::getNumBucket() const
 
 void DHTRoutingTable::showBuckets() const
 {/*
-   for(std::deque<SharedHandle<DHTBucket> >::const_iterator itr = buckets_.begin(); itr != buckets_.end(); ++itr) {
+   for(std::deque<std::shared_ptr<DHTBucket> >::const_iterator itr = buckets_.begin(); itr != buckets_.end(); ++itr) {
    cerr << "prefix = " << (*itr)->getPrefixLength() << ", "
    << "nodes = " << (*itr)->countNode() << endl;
    }
  */
 }
 
-SharedHandle<DHTBucket> DHTRoutingTable::getBucketFor(const unsigned char* nodeID) const
+std::shared_ptr<DHTBucket> DHTRoutingTable::getBucketFor(const unsigned char* nodeID) const
 {
   return dht::findBucketFor(root_, nodeID);
 }
 
-SharedHandle<DHTBucket> DHTRoutingTable::getBucketFor(const SharedHandle<DHTNode>& node) const
+std::shared_ptr<DHTBucket> DHTRoutingTable::getBucketFor(const std::shared_ptr<DHTNode>& node) const
 {
   return getBucketFor(node->getID());
 }
 
-SharedHandle<DHTNode> DHTRoutingTable::getNode(const unsigned char* nodeID, const std::string& ipaddr, uint16_t port) const
+std::shared_ptr<DHTNode> DHTRoutingTable::getNode(const unsigned char* nodeID, const std::string& ipaddr, uint16_t port) const
 {
-  SharedHandle<DHTBucket> bucket = getBucketFor(nodeID);
+  std::shared_ptr<DHTBucket> bucket = getBucketFor(nodeID);
   return bucket->getNode(nodeID, ipaddr, port);
 }
 
-void DHTRoutingTable::dropNode(const SharedHandle<DHTNode>& node)
+void DHTRoutingTable::dropNode(const std::shared_ptr<DHTNode>& node)
 {
   getBucketFor(node)->dropNode(node);
 }
 /*
-  void DHTRoutingTable::moveBucketHead(const SharedHandle<DHTNode>& node)
+  void DHTRoutingTable::moveBucketHead(const std::shared_ptr<DHTNode>& node)
   {
   getBucketFor(node)->moveToHead(node);
   }
 */
-void DHTRoutingTable::moveBucketTail(const SharedHandle<DHTNode>& node)
+void DHTRoutingTable::moveBucketTail(const std::shared_ptr<DHTNode>& node)
 {
   getBucketFor(node)->moveToTail(node);
 }
 
 void DHTRoutingTable::getBuckets
-(std::vector<SharedHandle<DHTBucket> >& buckets) const
+(std::vector<std::shared_ptr<DHTBucket> >& buckets) const
 {
   dht::enumerateBucket(buckets, root_);
 }
 
-void DHTRoutingTable::setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue)
+void DHTRoutingTable::setTaskQueue(const std::shared_ptr<DHTTaskQueue>& taskQueue)
 {
   taskQueue_ = taskQueue;
 }
 
-void DHTRoutingTable::setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory)
+void DHTRoutingTable::setTaskFactory(const std::shared_ptr<DHTTaskFactory>& taskFactory)
 {
   taskFactory_ = taskFactory;
 }
diff --git a/src/DHTRoutingTable.h b/src/DHTRoutingTable.h
index d7fb0b6f..a0708ac7 100644
--- a/src/DHTRoutingTable.h
+++ b/src/DHTRoutingTable.h
@@ -39,8 +39,7 @@
 
 #include <string>
 #include <vector>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -52,50 +51,50 @@ class DHTBucketTreeNode;
 
 class DHTRoutingTable {
 private:
-  SharedHandle<DHTNode> localNode_;
+  std::shared_ptr<DHTNode> localNode_;
 
   DHTBucketTreeNode* root_;
 
   int numBucket_;
 
-  SharedHandle<DHTTaskQueue> taskQueue_;
+  std::shared_ptr<DHTTaskQueue> taskQueue_;
 
-  SharedHandle<DHTTaskFactory> taskFactory_;
+  std::shared_ptr<DHTTaskFactory> taskFactory_;
 
-  bool addNode(const SharedHandle<DHTNode>& node, bool good);
+  bool addNode(const std::shared_ptr<DHTNode>& node, bool good);
 public:
-  DHTRoutingTable(const SharedHandle<DHTNode>& localNode);
+  DHTRoutingTable(const std::shared_ptr<DHTNode>& localNode);
 
   ~DHTRoutingTable();
 
-  bool addNode(const SharedHandle<DHTNode>& node);
+  bool addNode(const std::shared_ptr<DHTNode>& node);
 
-  bool addGoodNode(const SharedHandle<DHTNode>& node);
+  bool addGoodNode(const std::shared_ptr<DHTNode>& node);
 
-  void getClosestKNodes(std::vector<SharedHandle<DHTNode> >& nodes,
+  void getClosestKNodes(std::vector<std::shared_ptr<DHTNode> >& nodes,
                         const unsigned char* key) const;
 
   int getNumBucket() const;
 
   void showBuckets() const;
 
-  void dropNode(const SharedHandle<DHTNode>& node);
+  void dropNode(const std::shared_ptr<DHTNode>& node);
 
-  void moveBucketHead(const SharedHandle<DHTNode>& node);
+  void moveBucketHead(const std::shared_ptr<DHTNode>& node);
 
-  void moveBucketTail(const SharedHandle<DHTNode>& node);
+  void moveBucketTail(const std::shared_ptr<DHTNode>& node);
 
-  SharedHandle<DHTBucket> getBucketFor(const unsigned char* nodeID) const;
+  std::shared_ptr<DHTBucket> getBucketFor(const unsigned char* nodeID) const;
 
-  SharedHandle<DHTBucket> getBucketFor(const SharedHandle<DHTNode>& node) const;
+  std::shared_ptr<DHTBucket> getBucketFor(const std::shared_ptr<DHTNode>& node) const;
 
-  SharedHandle<DHTNode> getNode(const unsigned char* id, const std::string& ipaddr, uint16_t port) const;
+  std::shared_ptr<DHTNode> getNode(const unsigned char* id, const std::string& ipaddr, uint16_t port) const;
 
-  void getBuckets(std::vector<SharedHandle<DHTBucket> >& buckets) const;
+  void getBuckets(std::vector<std::shared_ptr<DHTBucket> >& buckets) const;
 
-  void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);
+  void setTaskQueue(const std::shared_ptr<DHTTaskQueue>& taskQueue);
 
-  void setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory);
+  void setTaskFactory(const std::shared_ptr<DHTTaskFactory>& taskFactory);
 };
 
 } // namespace aria2
diff --git a/src/DHTRoutingTableDeserializer.cc b/src/DHTRoutingTableDeserializer.cc
index f580415c..b1a2ce3b 100644
--- a/src/DHTRoutingTableDeserializer.cc
+++ b/src/DHTRoutingTableDeserializer.cc
@@ -144,7 +144,7 @@ void DHTRoutingTableDeserializer::deserialize(const std::string& filename)
   readBytes(fp, buf, buf.size(), 8);
   // localnode ID
   readBytes(fp, buf, buf.size(), DHT_ID_LENGTH);
-  SharedHandle<DHTNode> localNode(new DHTNode(buf));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(buf));
   // 4bytes reserved
   readBytes(fp, buf, buf.size(), 4);
 
@@ -154,7 +154,7 @@ void DHTRoutingTableDeserializer::deserialize(const std::string& filename)
   // 4bytes reserved
   readBytes(fp, buf, buf.size(), 4);
 
-  std::vector<SharedHandle<DHTNode> > nodes;
+  std::vector<std::shared_ptr<DHTNode> > nodes;
   // nodes
   const int compactlen = bittorrent::getCompactLength(family_);
   for(size_t i = 0; i < numNodes; ++i) {
@@ -187,7 +187,7 @@ void DHTRoutingTableDeserializer::deserialize(const std::string& filename)
     // node ID
     readBytes(fp, buf, buf.size(), DHT_ID_LENGTH);
 
-    SharedHandle<DHTNode> node(new DHTNode(buf));
+    std::shared_ptr<DHTNode> node(new DHTNode(buf));
     node->setIPAddress(peer.first);
     node->setPort(peer.second);
     // 4bytes reserved
diff --git a/src/DHTRoutingTableDeserializer.h b/src/DHTRoutingTableDeserializer.h
index a94acb94..6e772905 100644
--- a/src/DHTRoutingTableDeserializer.h
+++ b/src/DHTRoutingTableDeserializer.h
@@ -39,8 +39,8 @@
 
 #include <vector>
 #include <string>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimeA2.h"
 
 namespace aria2 {
@@ -51,9 +51,9 @@ class DHTRoutingTableDeserializer {
 private:
   int family_;
 
-  SharedHandle<DHTNode> localNode_;
+  std::shared_ptr<DHTNode> localNode_;
 
-  std::vector<SharedHandle<DHTNode> > nodes_;
+  std::vector<std::shared_ptr<DHTNode> > nodes_;
 
   Time serializedTime_;
 public:
@@ -61,12 +61,12 @@ public:
 
   ~DHTRoutingTableDeserializer();
 
-  const SharedHandle<DHTNode>& getLocalNode() const
+  const std::shared_ptr<DHTNode>& getLocalNode() const
   {
     return localNode_;
   }
 
-  const std::vector<SharedHandle<DHTNode> >& getNodes() const
+  const std::vector<std::shared_ptr<DHTNode> >& getNodes() const
   {
     return nodes_;
   }
diff --git a/src/DHTRoutingTableSerializer.cc b/src/DHTRoutingTableSerializer.cc
index 2aa76a78..dc4a27cb 100644
--- a/src/DHTRoutingTableSerializer.cc
+++ b/src/DHTRoutingTableSerializer.cc
@@ -58,13 +58,13 @@ DHTRoutingTableSerializer::DHTRoutingTableSerializer(int family):
 DHTRoutingTableSerializer::~DHTRoutingTableSerializer() {}
 
 void DHTRoutingTableSerializer::setLocalNode
-(const SharedHandle<DHTNode>& localNode)
+(const std::shared_ptr<DHTNode>& localNode)
 {
   localNode_ = localNode;
 }
 
 void DHTRoutingTableSerializer::setNodes
-(const std::vector<SharedHandle<DHTNode> >& nodes)
+(const std::vector<std::shared_ptr<DHTNode> >& nodes)
 {
   nodes_ = nodes;
 }
@@ -120,9 +120,9 @@ void DHTRoutingTableSerializer::serialize(const std::string& filename)
 
   const int clen = bittorrent::getCompactLength(family_);
   // nodes
-  for(std::vector<SharedHandle<DHTNode> >::const_iterator i = nodes_.begin(),
+  for(std::vector<std::shared_ptr<DHTNode> >::const_iterator i = nodes_.begin(),
         eoi = nodes_.end(); i != eoi; ++i) {
-    const SharedHandle<DHTNode>& node = *i;
+    const std::shared_ptr<DHTNode>& node = *i;
     // Write IP address + port in Compact IP-address/port info form.
     unsigned char compactPeer[COMPACT_LEN_IPV6];
     int compactlen = bittorrent::packcompact
diff --git a/src/DHTRoutingTableSerializer.h b/src/DHTRoutingTableSerializer.h
index f0b703fd..8d45b9b6 100644
--- a/src/DHTRoutingTableSerializer.h
+++ b/src/DHTRoutingTableSerializer.h
@@ -39,8 +39,7 @@
 
 #include <vector>
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -50,17 +49,17 @@ class DHTRoutingTableSerializer {
 private:
   int family_;
 
-  SharedHandle<DHTNode> localNode_;
+  std::shared_ptr<DHTNode> localNode_;
 
-  std::vector<SharedHandle<DHTNode> > nodes_;
+  std::vector<std::shared_ptr<DHTNode> > nodes_;
 public:
   DHTRoutingTableSerializer(int family);
 
   ~DHTRoutingTableSerializer();
 
-  void setLocalNode(const SharedHandle<DHTNode>& localNode);
+  void setLocalNode(const std::shared_ptr<DHTNode>& localNode);
 
-  void setNodes(const std::vector<SharedHandle<DHTNode> >& nodes);
+  void setNodes(const std::vector<std::shared_ptr<DHTNode> >& nodes);
 
   void serialize(const std::string& filename);
 };
diff --git a/src/DHTSetup.cc b/src/DHTSetup.cc
index 13df226c..f2842535 100644
--- a/src/DHTSetup.cc
+++ b/src/DHTSetup.cc
@@ -93,7 +93,7 @@ void DHTSetup::setup
     auto_delete_container<std::vector<Command*> > commandsDel(tempCommands);
     // load routing table and localnode id here
 
-    SharedHandle<DHTNode> localNode;
+    std::shared_ptr<DHTNode> localNode;
 
     DHTRoutingTableDeserializer deserializer(family);
     const std::string& dhtFile =
@@ -113,7 +113,7 @@ void DHTSetup::setup
     }
 
     uint16_t port;
-    SharedHandle<DHTConnectionImpl> connection(new DHTConnectionImpl(family));
+    std::shared_ptr<DHTConnectionImpl> connection(new DHTConnectionImpl(family));
     {
       port = e->getBtRegistry()->getUdpPort();
       const std::string& addr =
@@ -139,24 +139,24 @@ void DHTSetup::setup
     }
     A2_LOG_DEBUG(fmt("Initialized local node ID=%s",
                      util::toHex(localNode->getID(), DHT_ID_LENGTH).c_str()));
-    SharedHandle<DHTRoutingTable> routingTable(new DHTRoutingTable(localNode));
+    std::shared_ptr<DHTRoutingTable> routingTable(new DHTRoutingTable(localNode));
 
-    SharedHandle<DHTMessageFactoryImpl> factory
+    std::shared_ptr<DHTMessageFactoryImpl> factory
       (new DHTMessageFactoryImpl(family));
 
-    SharedHandle<DHTMessageTracker> tracker(new DHTMessageTracker());
+    std::shared_ptr<DHTMessageTracker> tracker(new DHTMessageTracker());
 
-    SharedHandle<DHTMessageDispatcherImpl> dispatcher(new DHTMessageDispatcherImpl(tracker));
+    std::shared_ptr<DHTMessageDispatcherImpl> dispatcher(new DHTMessageDispatcherImpl(tracker));
 
-    SharedHandle<DHTMessageReceiver> receiver(new DHTMessageReceiver(tracker));
+    std::shared_ptr<DHTMessageReceiver> receiver(new DHTMessageReceiver(tracker));
 
-    SharedHandle<DHTTaskQueue> taskQueue(new DHTTaskQueueImpl());
+    std::shared_ptr<DHTTaskQueue> taskQueue(new DHTTaskQueueImpl());
 
-    SharedHandle<DHTTaskFactoryImpl> taskFactory(new DHTTaskFactoryImpl());
+    std::shared_ptr<DHTTaskFactoryImpl> taskFactory(new DHTTaskFactoryImpl());
 
-    SharedHandle<DHTPeerAnnounceStorage> peerAnnounceStorage(new DHTPeerAnnounceStorage());
+    std::shared_ptr<DHTPeerAnnounceStorage> peerAnnounceStorage(new DHTPeerAnnounceStorage());
 
-    SharedHandle<DHTTokenTracker> tokenTracker(new DHTTokenTracker());
+    std::shared_ptr<DHTTokenTracker> tokenTracker(new DHTTokenTracker());
 
     const time_t messageTimeout = e->getOption()->getAsInt(PREF_DHT_MESSAGE_TIMEOUT);
     // wiring up
@@ -190,7 +190,7 @@ void DHTSetup::setup
     factory->setLocalNode(localNode);
 
     // For now, UDPTrackerClient was enabled along with DHT
-    SharedHandle<UDPTrackerClient> udpTrackerClient(new UDPTrackerClient());
+    std::shared_ptr<UDPTrackerClient> udpTrackerClient(new UDPTrackerClient());
     // assign them into DHTRegistry
     if(family == AF_INET) {
       DHTRegistry::getMutableData().localNode = localNode;
@@ -215,16 +215,15 @@ void DHTSetup::setup
       DHTRegistry::getMutableData6().messageFactory = factory;
     }
     // add deserialized nodes to routing table
-    const std::vector<SharedHandle<DHTNode> >& desnodes =
+    const std::vector<std::shared_ptr<DHTNode> >& desnodes =
       deserializer.getNodes();
-    for(std::vector<SharedHandle<DHTNode> >::const_iterator i =
+    for(std::vector<std::shared_ptr<DHTNode> >::const_iterator i =
           desnodes.begin(), eoi = desnodes.end(); i != eoi; ++i) {
       routingTable->addNode(*i);
     }
     if(!desnodes.empty()) {
-      SharedHandle<DHTBucketRefreshTask> task
-        (static_pointer_cast<DHTBucketRefreshTask>
-         (taskFactory->createBucketRefreshTask()));
+      auto task = std::static_pointer_cast<DHTBucketRefreshTask>
+        (taskFactory->createBucketRefreshTask());
       task->setForceRefresh(true);
       taskQueue->addPeriodicTask1(task);
     }
@@ -311,7 +310,7 @@ void DHTSetup::setup
     if(family == AF_INET) {
       DHTRegistry::clearData();
       e->getBtRegistry()->setUDPTrackerClient
-        (SharedHandle<UDPTrackerClient>());
+        (std::shared_ptr<UDPTrackerClient>());
     } else {
       DHTRegistry::clearData6();
     }
diff --git a/src/DHTTaskExecutor.cc b/src/DHTTaskExecutor.cc
index ba57c1f3..9179dbe4 100644
--- a/src/DHTTaskExecutor.cc
+++ b/src/DHTTaskExecutor.cc
@@ -62,7 +62,7 @@ void DHTTaskExecutor::update()
     r = 0;
   }
   while(r && !queue_.empty()) {
-    SharedHandle<DHTTask> task = queue_.front();
+    std::shared_ptr<DHTTask> task = queue_.front();
     queue_.pop_front();
     task->startup();
     if(!task->finished()) {
diff --git a/src/DHTTaskExecutor.h b/src/DHTTaskExecutor.h
index f64fd6c6..c50f52d3 100644
--- a/src/DHTTaskExecutor.h
+++ b/src/DHTTaskExecutor.h
@@ -39,8 +39,7 @@
 
 #include <vector>
 #include <deque>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -49,8 +48,8 @@ class DHTTask;
 class DHTTaskExecutor {
 private:
   int numConcurrent_;
-  std::vector<SharedHandle<DHTTask> > execTasks_;
-  std::deque<SharedHandle<DHTTask> > queue_;
+  std::vector<std::shared_ptr<DHTTask> > execTasks_;
+  std::deque<std::shared_ptr<DHTTask> > queue_;
 public:
   DHTTaskExecutor(int numConcurrent);
 
@@ -58,7 +57,7 @@ public:
 
   void update();
 
-  void addTask(const SharedHandle<DHTTask>& task)
+  void addTask(const std::shared_ptr<DHTTask>& task)
   {
     queue_.push_back(task);
   }
diff --git a/src/DHTTaskFactory.h b/src/DHTTaskFactory.h
index 90434696..7d329d92 100644
--- a/src/DHTTaskFactory.h
+++ b/src/DHTTaskFactory.h
@@ -36,7 +36,8 @@
 #define D_DHT_TASK_FACTORY_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -50,26 +51,26 @@ class DHTTaskFactory {
 public:
   virtual ~DHTTaskFactory() {}
 
-  virtual SharedHandle<DHTTask>
-  createPingTask(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTTask>
+  createPingTask(const std::shared_ptr<DHTNode>& remoteNode,
                  int numRetry = 0) = 0;
 
-  virtual SharedHandle<DHTTask>
+  virtual std::shared_ptr<DHTTask>
   createNodeLookupTask(const unsigned char* targetID) = 0;
 
-  virtual SharedHandle<DHTTask> createBucketRefreshTask() = 0;
+  virtual std::shared_ptr<DHTTask> createBucketRefreshTask() = 0;
 
-  virtual SharedHandle<DHTTask>
-  createPeerLookupTask(const SharedHandle<DownloadContext>& ctx,
+  virtual std::shared_ptr<DHTTask>
+  createPeerLookupTask(const std::shared_ptr<DownloadContext>& ctx,
                        uint16_t tcpPort,
-                       const SharedHandle<PeerStorage>& peerStorage) = 0;
+                       const std::shared_ptr<PeerStorage>& peerStorage) = 0;
 
-  virtual SharedHandle<DHTTask>
+  virtual std::shared_ptr<DHTTask>
   createPeerAnnounceTask(const unsigned char* infoHash) = 0;
 
-  virtual SharedHandle<DHTTask>
-  createReplaceNodeTask(const SharedHandle<DHTBucket>& bucket,
-                        const SharedHandle<DHTNode>& newNode) = 0;
+  virtual std::shared_ptr<DHTTask>
+  createReplaceNodeTask(const std::shared_ptr<DHTBucket>& bucket,
+                        const std::shared_ptr<DHTNode>& newNode) = 0;
 };
 
 } // namespace aria2
diff --git a/src/DHTTaskFactoryImpl.cc b/src/DHTTaskFactoryImpl.cc
index aec36c7c..2bed9da5 100644
--- a/src/DHTTaskFactoryImpl.cc
+++ b/src/DHTTaskFactoryImpl.cc
@@ -60,63 +60,63 @@ DHTTaskFactoryImpl::DHTTaskFactoryImpl()
 
 DHTTaskFactoryImpl::~DHTTaskFactoryImpl() {}
 
-SharedHandle<DHTTask>
-DHTTaskFactoryImpl::createPingTask(const SharedHandle<DHTNode>& remoteNode,
+std::shared_ptr<DHTTask>
+DHTTaskFactoryImpl::createPingTask(const std::shared_ptr<DHTNode>& remoteNode,
                                    int numRetry)
 {
-  SharedHandle<DHTPingTask> task(new DHTPingTask(remoteNode, numRetry));
+  std::shared_ptr<DHTPingTask> task(new DHTPingTask(remoteNode, numRetry));
   task->setTimeout(timeout_);
   setCommonProperty(task);
   return task;
 }
 
-SharedHandle<DHTTask>
+std::shared_ptr<DHTTask>
 DHTTaskFactoryImpl::createNodeLookupTask(const unsigned char* targetID)
 {
-  SharedHandle<DHTNodeLookupTask> task(new DHTNodeLookupTask(targetID));
+  std::shared_ptr<DHTNodeLookupTask> task(new DHTNodeLookupTask(targetID));
   setCommonProperty(task);
   return task;
 }
 
-SharedHandle<DHTTask>
+std::shared_ptr<DHTTask>
 DHTTaskFactoryImpl::createBucketRefreshTask()
 {
-  SharedHandle<DHTBucketRefreshTask> task(new DHTBucketRefreshTask());
+  std::shared_ptr<DHTBucketRefreshTask> task(new DHTBucketRefreshTask());
   setCommonProperty(task);
   return task;
 }
 
-SharedHandle<DHTTask>
+std::shared_ptr<DHTTask>
 DHTTaskFactoryImpl::createPeerLookupTask
-(const SharedHandle<DownloadContext>& ctx,
+(const std::shared_ptr<DownloadContext>& ctx,
  uint16_t tcpPort,
- const SharedHandle<PeerStorage>& peerStorage)
+ const std::shared_ptr<PeerStorage>& peerStorage)
 {
-  SharedHandle<DHTPeerLookupTask> task(new DHTPeerLookupTask(ctx, tcpPort));
+  std::shared_ptr<DHTPeerLookupTask> task(new DHTPeerLookupTask(ctx, tcpPort));
   // TODO this may be not freed by RequestGroup::releaseRuntimeResource()
   task->setPeerStorage(peerStorage);
   setCommonProperty(task);
   return task;
 }
 
-SharedHandle<DHTTask>
+std::shared_ptr<DHTTask>
 DHTTaskFactoryImpl::createPeerAnnounceTask(const unsigned char* infoHash)
 {
   // TODO
-  return SharedHandle<DHTTask>();
+  return std::shared_ptr<DHTTask>();
 }
 
-SharedHandle<DHTTask>
-DHTTaskFactoryImpl::createReplaceNodeTask(const SharedHandle<DHTBucket>& bucket,
-                                          const SharedHandle<DHTNode>& newNode)
+std::shared_ptr<DHTTask>
+DHTTaskFactoryImpl::createReplaceNodeTask(const std::shared_ptr<DHTBucket>& bucket,
+                                          const std::shared_ptr<DHTNode>& newNode)
 {
-  SharedHandle<DHTReplaceNodeTask> task(new DHTReplaceNodeTask(bucket, newNode));
+  std::shared_ptr<DHTReplaceNodeTask> task(new DHTReplaceNodeTask(bucket, newNode));
   task->setTimeout(timeout_);
   setCommonProperty(task);
   return task;
 }
 
-void DHTTaskFactoryImpl::setCommonProperty(const SharedHandle<DHTAbstractTask>& task)
+void DHTTaskFactoryImpl::setCommonProperty(const std::shared_ptr<DHTAbstractTask>& task)
 {
   task->setRoutingTable(routingTable_);
   task->setMessageDispatcher(dispatcher_);
@@ -145,7 +145,7 @@ void DHTTaskFactoryImpl::setTaskQueue(DHTTaskQueue* taskQueue)
   taskQueue_ = taskQueue;
 }
 
-void DHTTaskFactoryImpl::setLocalNode(const SharedHandle<DHTNode>& localNode)
+void DHTTaskFactoryImpl::setLocalNode(const std::shared_ptr<DHTNode>& localNode)
 {
   localNode_ = localNode;
 }
diff --git a/src/DHTTaskFactoryImpl.h b/src/DHTTaskFactoryImpl.h
index aef197f2..baded49d 100644
--- a/src/DHTTaskFactoryImpl.h
+++ b/src/DHTTaskFactoryImpl.h
@@ -49,7 +49,7 @@ class DHTAbstractTask;
 
 class DHTTaskFactoryImpl:public DHTTaskFactory {
 private:
-  SharedHandle<DHTNode> localNode_;
+  std::shared_ptr<DHTNode> localNode_;
 
   DHTRoutingTable* routingTable_;
 
@@ -61,32 +61,32 @@ private:
 
   time_t timeout_;
 
-  void setCommonProperty(const SharedHandle<DHTAbstractTask>& task);
+  void setCommonProperty(const std::shared_ptr<DHTAbstractTask>& task);
 public:
   DHTTaskFactoryImpl();
 
   virtual ~DHTTaskFactoryImpl();
 
-  virtual SharedHandle<DHTTask>
-  createPingTask(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTTask>
+  createPingTask(const std::shared_ptr<DHTNode>& remoteNode,
                  int numRetry = 0);
 
-  virtual SharedHandle<DHTTask>
+  virtual std::shared_ptr<DHTTask>
   createNodeLookupTask(const unsigned char* targetID);
 
-  virtual SharedHandle<DHTTask> createBucketRefreshTask();
+  virtual std::shared_ptr<DHTTask> createBucketRefreshTask();
 
-  virtual SharedHandle<DHTTask>
-  createPeerLookupTask(const SharedHandle<DownloadContext>& ctx,
+  virtual std::shared_ptr<DHTTask>
+  createPeerLookupTask(const std::shared_ptr<DownloadContext>& ctx,
                        uint16_t tcpPort,
-                       const SharedHandle<PeerStorage>& peerStorage);
+                       const std::shared_ptr<PeerStorage>& peerStorage);
 
-  virtual SharedHandle<DHTTask>
+  virtual std::shared_ptr<DHTTask>
   createPeerAnnounceTask(const unsigned char* infoHash);
 
-  virtual SharedHandle<DHTTask>
-  createReplaceNodeTask(const SharedHandle<DHTBucket>& bucket,
-                        const SharedHandle<DHTNode>& newNode);
+  virtual std::shared_ptr<DHTTask>
+  createReplaceNodeTask(const std::shared_ptr<DHTBucket>& bucket,
+                        const std::shared_ptr<DHTNode>& newNode);
 
   void setRoutingTable(DHTRoutingTable* routingTable);
 
@@ -96,7 +96,7 @@ public:
 
   void setTaskQueue(DHTTaskQueue* taskQueue);
 
-  void setLocalNode(const SharedHandle<DHTNode>& localNode);
+  void setLocalNode(const std::shared_ptr<DHTNode>& localNode);
 
   void setTimeout(time_t timeout)
   {
diff --git a/src/DHTTaskQueue.h b/src/DHTTaskQueue.h
index c7596aeb..dad5e99f 100644
--- a/src/DHTTaskQueue.h
+++ b/src/DHTTaskQueue.h
@@ -36,7 +36,8 @@
 #define D_DHT_TASK_QUEUE_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -48,11 +49,11 @@ public:
 
   virtual void executeTask() = 0;
 
-  virtual void addPeriodicTask1(const SharedHandle<DHTTask>& task) = 0;
+  virtual void addPeriodicTask1(const std::shared_ptr<DHTTask>& task) = 0;
 
-  virtual void addPeriodicTask2(const SharedHandle<DHTTask>& task) = 0;
+  virtual void addPeriodicTask2(const std::shared_ptr<DHTTask>& task) = 0;
 
-  virtual void addImmediateTask(const SharedHandle<DHTTask>& task) = 0;
+  virtual void addImmediateTask(const std::shared_ptr<DHTTask>& task) = 0;
 };
 
 } // namespace aria2
diff --git a/src/DHTTaskQueueImpl.cc b/src/DHTTaskQueueImpl.cc
index 505fb010..2097aae9 100644
--- a/src/DHTTaskQueueImpl.cc
+++ b/src/DHTTaskQueueImpl.cc
@@ -61,17 +61,17 @@ void DHTTaskQueueImpl::executeTask()
   immediateTaskQueue_.update();
 }
 
-void DHTTaskQueueImpl::addPeriodicTask1(const SharedHandle<DHTTask>& task)
+void DHTTaskQueueImpl::addPeriodicTask1(const std::shared_ptr<DHTTask>& task)
 {
   periodicTaskQueue1_.addTask(task);
 }
 
-void DHTTaskQueueImpl::addPeriodicTask2(const SharedHandle<DHTTask>& task)
+void DHTTaskQueueImpl::addPeriodicTask2(const std::shared_ptr<DHTTask>& task)
 {
   periodicTaskQueue2_.addTask(task);
 }
 
-void DHTTaskQueueImpl::addImmediateTask(const SharedHandle<DHTTask>& task)
+void DHTTaskQueueImpl::addImmediateTask(const std::shared_ptr<DHTTask>& task)
 {
   immediateTaskQueue_.addTask(task);
 }
diff --git a/src/DHTTaskQueueImpl.h b/src/DHTTaskQueueImpl.h
index 87c0eaf0..eb21e620 100644
--- a/src/DHTTaskQueueImpl.h
+++ b/src/DHTTaskQueueImpl.h
@@ -54,11 +54,11 @@ public:
 
   virtual void executeTask();
 
-  virtual void addPeriodicTask1(const SharedHandle<DHTTask>& task);
+  virtual void addPeriodicTask1(const std::shared_ptr<DHTTask>& task);
 
-  virtual void addPeriodicTask2(const SharedHandle<DHTTask>& task);
+  virtual void addPeriodicTask2(const std::shared_ptr<DHTTask>& task);
 
-  virtual void addImmediateTask(const SharedHandle<DHTTask>& task);
+  virtual void addImmediateTask(const std::shared_ptr<DHTTask>& task);
 };
 
 } // namespace aria2
diff --git a/src/DHTTokenUpdateCommand.cc b/src/DHTTokenUpdateCommand.cc
index 176cb6a9..d7ccb6d4 100644
--- a/src/DHTTokenUpdateCommand.cc
+++ b/src/DHTTokenUpdateCommand.cc
@@ -67,7 +67,7 @@ void DHTTokenUpdateCommand::process()
   }
 }
 
-void DHTTokenUpdateCommand::setTokenTracker(const SharedHandle<DHTTokenTracker>& tokenTracker)
+void DHTTokenUpdateCommand::setTokenTracker(const std::shared_ptr<DHTTokenTracker>& tokenTracker)
 {
   tokenTracker_ = tokenTracker;
 }
diff --git a/src/DHTTokenUpdateCommand.h b/src/DHTTokenUpdateCommand.h
index ecb6d8af..cec5ca30 100644
--- a/src/DHTTokenUpdateCommand.h
+++ b/src/DHTTokenUpdateCommand.h
@@ -36,7 +36,8 @@
 #define D_DHT_TOKEN_UPDATE_COMMAND_H
 
 #include "TimeBasedCommand.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -44,7 +45,7 @@ class DHTTokenTracker;
 
 class DHTTokenUpdateCommand:public TimeBasedCommand {
 private:
-  SharedHandle<DHTTokenTracker> tokenTracker_;
+  std::shared_ptr<DHTTokenTracker> tokenTracker_;
 public:
   DHTTokenUpdateCommand(cuid_t cuid, DownloadEngine* e, time_t interval);
 
@@ -54,7 +55,7 @@ public:
 
   virtual void process();
 
-  void setTokenTracker(const SharedHandle<DHTTokenTracker>& tokenTracker);
+  void setTokenTracker(const std::shared_ptr<DHTTokenTracker>& tokenTracker);
 };
 
 } // namespace aria2
diff --git a/src/DHTUnknownMessage.cc b/src/DHTUnknownMessage.cc
index 268b30a0..46cdaf5c 100644
--- a/src/DHTUnknownMessage.cc
+++ b/src/DHTUnknownMessage.cc
@@ -47,10 +47,10 @@ const std::string DHTUnknownMessage::E("e");
 
 const std::string DHTUnknownMessage::UNKNOWN("unknown");
 
-DHTUnknownMessage::DHTUnknownMessage(const SharedHandle<DHTNode>& localNode,
+DHTUnknownMessage::DHTUnknownMessage(const std::shared_ptr<DHTNode>& localNode,
                                      const unsigned char* data, size_t length,
                                      const std::string& ipaddr, uint16_t port):
-  DHTMessage(localNode, SharedHandle<DHTNode>()),
+  DHTMessage(localNode, std::shared_ptr<DHTNode>()),
   length_(length),
   ipaddr_(ipaddr),
   port_(port)
diff --git a/src/DHTUnknownMessage.h b/src/DHTUnknownMessage.h
index 683fa19b..2ad03cbb 100644
--- a/src/DHTUnknownMessage.h
+++ b/src/DHTUnknownMessage.h
@@ -47,7 +47,7 @@ private:
   uint16_t port_;
 public:
   // _remoteNode is always null
-  DHTUnknownMessage(const SharedHandle<DHTNode>& localNode,
+  DHTUnknownMessage(const std::shared_ptr<DHTNode>& localNode,
                     const unsigned char* data, size_t length,
                     const std::string& ipaddr, uint16_t port);
 
diff --git a/src/DNSCache.cc b/src/DNSCache.cc
index 5ffdb831..6097df1d 100644
--- a/src/DNSCache.cc
+++ b/src/DNSCache.cc
@@ -167,7 +167,7 @@ DNSCache& DNSCache::operator=(const DNSCache& c)
 const std::string& DNSCache::find
 (const std::string& hostname, uint16_t port) const
 {
-  SharedHandle<CacheEntry> target(new CacheEntry(hostname, port));
+  std::shared_ptr<CacheEntry> target(new CacheEntry(hostname, port));
   CacheEntrySet::iterator i = entries_.find(target);
   if(i == entries_.end()) {
     return A2STR::NIL;
@@ -179,7 +179,7 @@ const std::string& DNSCache::find
 void DNSCache::put
 (const std::string& hostname, const std::string& ipaddr, uint16_t port)
 {
-  SharedHandle<CacheEntry> target(new CacheEntry(hostname, port));
+  std::shared_ptr<CacheEntry> target(new CacheEntry(hostname, port));
   CacheEntrySet::iterator i = entries_.lower_bound(target);
   if(i != entries_.end() && *(*i) == *target) {
     (*i)->add(ipaddr);
@@ -192,7 +192,7 @@ void DNSCache::put
 void DNSCache::markBad
 (const std::string& hostname, const std::string& ipaddr, uint16_t port)
 {
-  SharedHandle<CacheEntry> target(new CacheEntry(hostname, port));
+  std::shared_ptr<CacheEntry> target(new CacheEntry(hostname, port));
   CacheEntrySet::iterator i = entries_.find(target);
   if(i != entries_.end()) {
     (*i)->markBad(ipaddr);
@@ -201,7 +201,7 @@ void DNSCache::markBad
 
 void DNSCache::remove(const std::string& hostname, uint16_t port)
 {
-  SharedHandle<CacheEntry> target(new CacheEntry(hostname, port));
+  std::shared_ptr<CacheEntry> target(new CacheEntry(hostname, port));
   entries_.erase(target);
 }
 
diff --git a/src/DNSCache.h b/src/DNSCache.h
index 49606e62..ed4de417 100644
--- a/src/DNSCache.h
+++ b/src/DNSCache.h
@@ -98,8 +98,8 @@ private:
     bool operator==(const CacheEntry& e) const;
   };
 
-  typedef std::set<SharedHandle<CacheEntry>,
-                   DerefLess<SharedHandle<CacheEntry> > > CacheEntrySet;
+  typedef std::set<std::shared_ptr<CacheEntry>,
+                   DerefLess<std::shared_ptr<CacheEntry> > > CacheEntrySet;
   CacheEntrySet entries_;
 public:
   DNSCache();
@@ -114,7 +114,7 @@ public:
   void findAll
   (OutputIterator out, const std::string& hostname, uint16_t port) const
   {
-    SharedHandle<CacheEntry> target(new CacheEntry(hostname, port));
+    std::shared_ptr<CacheEntry> target(new CacheEntry(hostname, port));
     CacheEntrySet::iterator i = entries_.find(target);
     if(i != entries_.end()) {
       (*i)->getAllGoodAddrs(out);
diff --git a/src/DefaultAuthResolver.cc b/src/DefaultAuthResolver.cc
index dc5f01c7..2cb589cf 100644
--- a/src/DefaultAuthResolver.cc
+++ b/src/DefaultAuthResolver.cc
@@ -37,7 +37,7 @@
 
 namespace aria2 {
 
-SharedHandle<AuthConfig> DefaultAuthResolver::resolveAuthConfig
+std::shared_ptr<AuthConfig> DefaultAuthResolver::resolveAuthConfig
 (const std::string& hostname)
 {
   if(!getUserDefinedAuthConfig()) {
diff --git a/src/DefaultAuthResolver.h b/src/DefaultAuthResolver.h
index bb2ec8e3..e3ddf509 100644
--- a/src/DefaultAuthResolver.h
+++ b/src/DefaultAuthResolver.h
@@ -41,7 +41,7 @@ namespace aria2 {
 
 class DefaultAuthResolver : public AbstractAuthResolver {
 public:
-  virtual SharedHandle<AuthConfig> resolveAuthConfig
+  virtual std::shared_ptr<AuthConfig> resolveAuthConfig
   (const std::string& hostname);
 };
 
diff --git a/src/DefaultBtAnnounce.cc b/src/DefaultBtAnnounce.cc
index a41f002d..f371def2 100644
--- a/src/DefaultBtAnnounce.cc
+++ b/src/DefaultBtAnnounce.cc
@@ -58,7 +58,7 @@
 namespace aria2 {
 
 DefaultBtAnnounce::DefaultBtAnnounce
-(const SharedHandle<DownloadContext>& downloadContext,
+(const std::shared_ptr<DownloadContext>& downloadContext,
  const Option* option)
   : downloadContext_(downloadContext),
     trackers_(0),
@@ -202,16 +202,16 @@ std::string DefaultBtAnnounce::getAnnounceUrl() {
   return uri;
 }
 
-SharedHandle<UDPTrackerRequest> DefaultBtAnnounce::createUDPTrackerRequest
+std::shared_ptr<UDPTrackerRequest> DefaultBtAnnounce::createUDPTrackerRequest
 (const std::string& remoteAddr, uint16_t remotePort, uint16_t localPort)
 {
   if(!adjustAnnounceList()) {
-    return SharedHandle<UDPTrackerRequest>();
+    return std::shared_ptr<UDPTrackerRequest>();
   }
   NetStat& stat = downloadContext_->getNetStat();
   int64_t left =
     pieceStorage_->getTotalLength()-pieceStorage_->getCompletedLength();
-  SharedHandle<UDPTrackerRequest> req(new UDPTrackerRequest());
+  std::shared_ptr<UDPTrackerRequest> req(new UDPTrackerRequest());
   req->remoteAddr = remoteAddr;
   req->remotePort = remotePort;
   req->action = UDPT_ACT_ANNOUNCE;
@@ -284,7 +284,7 @@ DefaultBtAnnounce::processAnnounceResponse(const unsigned char* trackerResponse,
                                            size_t trackerResponseLength)
 {
   A2_LOG_DEBUG("Now processing tracker response.");
-  SharedHandle<ValueBase> decodedValue =
+  std::shared_ptr<ValueBase> decodedValue =
     bencode2::decode(trackerResponse, trackerResponseLength);
   const Dict* dict = downcast<Dict>(decodedValue);
   if(!dict) {
@@ -328,22 +328,22 @@ DefaultBtAnnounce::processAnnounceResponse(const unsigned char* trackerResponse,
     incomplete_ = incomp->i();
     A2_LOG_DEBUG(fmt("Incomplete:%d", incomplete_));
   }
-  const SharedHandle<ValueBase>& peerData = dict->get(BtAnnounce::PEERS);
+  const std::shared_ptr<ValueBase>& peerData = dict->get(BtAnnounce::PEERS);
   if(!peerData) {
     A2_LOG_INFO(MSG_NO_PEER_LIST_RECEIVED);
   } else {
     if(!btRuntime_->isHalt() && btRuntime_->lessThanMinPeers()) {
-      std::vector<SharedHandle<Peer> > peers;
+      std::vector<std::shared_ptr<Peer> > peers;
       bittorrent::extractPeer(peerData, AF_INET, std::back_inserter(peers));
       peerStorage_->addPeer(peers);
     }
   }
-  const SharedHandle<ValueBase>& peer6Data = dict->get(BtAnnounce::PEERS6);
+  const std::shared_ptr<ValueBase>& peer6Data = dict->get(BtAnnounce::PEERS6);
   if(!peer6Data) {
     A2_LOG_INFO("No peers6 received.");
   } else {
     if(!btRuntime_->isHalt() && btRuntime_->lessThanMinPeers()) {
-      std::vector<SharedHandle<Peer> > peers;
+      std::vector<std::shared_ptr<Peer> > peers;
       bittorrent::extractPeer(peer6Data, AF_INET6, std::back_inserter(peers));
       peerStorage_->addPeer(peers);
     }
@@ -351,9 +351,9 @@ DefaultBtAnnounce::processAnnounceResponse(const unsigned char* trackerResponse,
 }
 
 void DefaultBtAnnounce::processUDPTrackerResponse
-(const SharedHandle<UDPTrackerRequest>& req)
+(const std::shared_ptr<UDPTrackerRequest>& req)
 {
-  const SharedHandle<UDPTrackerReply>& reply = req->reply;
+  const std::shared_ptr<UDPTrackerReply>& reply = req->reply;
   A2_LOG_DEBUG("Now processing UDP tracker response.");
   if(reply->interval > 0) {
     minInterval_ = reply->interval;
@@ -368,7 +368,7 @@ void DefaultBtAnnounce::processUDPTrackerResponse
     for(std::vector<std::pair<std::string, uint16_t> >::iterator i =
           reply->peers.begin(), eoi = reply->peers.end(); i != eoi;
         ++i) {
-      peerStorage_->addPeer(SharedHandle<Peer>(new Peer((*i).first,
+      peerStorage_->addPeer(std::shared_ptr<Peer>(new Peer((*i).first,
                                                         (*i).second)));
     }
   }
@@ -385,23 +385,23 @@ void DefaultBtAnnounce::shuffleAnnounce() {
 }
 
 void DefaultBtAnnounce::setRandomizer
-(const SharedHandle<Randomizer>& randomizer)
+(const std::shared_ptr<Randomizer>& randomizer)
 {
   randomizer_ = randomizer;
 }
 
-void DefaultBtAnnounce::setBtRuntime(const SharedHandle<BtRuntime>& btRuntime)
+void DefaultBtAnnounce::setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime)
 {
   btRuntime_ = btRuntime;
 }
 
-void DefaultBtAnnounce::setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage)
+void DefaultBtAnnounce::setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
 
 void DefaultBtAnnounce::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
diff --git a/src/DefaultBtAnnounce.h b/src/DefaultBtAnnounce.h
index 5428a42c..7c2f9eb8 100644
--- a/src/DefaultBtAnnounce.h
+++ b/src/DefaultBtAnnounce.h
@@ -50,7 +50,7 @@ class Randomizer;
 
 class DefaultBtAnnounce : public BtAnnounce {
 private:
-  SharedHandle<DownloadContext> downloadContext_;
+  std::shared_ptr<DownloadContext> downloadContext_;
   int trackers_;
   Timer prevAnnounceTimer_;
   time_t interval_;
@@ -61,36 +61,36 @@ private:
   AnnounceList announceList_;
   std::string trackerId_;
   const Option* option_;
-  SharedHandle<Randomizer> randomizer_;
-  SharedHandle<BtRuntime> btRuntime_;
-  SharedHandle<PieceStorage> pieceStorage_;
-  SharedHandle<PeerStorage> peerStorage_;
+  std::shared_ptr<Randomizer> randomizer_;
+  std::shared_ptr<BtRuntime> btRuntime_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
   uint16_t tcpPort_;
 
   bool adjustAnnounceList();
 public:
-  DefaultBtAnnounce(const SharedHandle<DownloadContext>& downloadContext,
+  DefaultBtAnnounce(const std::shared_ptr<DownloadContext>& downloadContext,
                     const Option* option);
 
   virtual ~DefaultBtAnnounce();
 
-  void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime);
+  void setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime);
 
-  const SharedHandle<BtRuntime>& getBtRuntime() const
+  const std::shared_ptr<BtRuntime>& getBtRuntime() const
   {
     return btRuntime_;
   }
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 
-  const SharedHandle<PieceStorage>& getPieceStorage() const
+  const std::shared_ptr<PieceStorage>& getPieceStorage() const
   {
     return pieceStorage_;
   }
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 
-  const SharedHandle<PeerStorage>& getPeerStorage() const
+  const std::shared_ptr<PeerStorage>& getPeerStorage() const
   {
     return peerStorage_;
   }
@@ -105,7 +105,7 @@ public:
 
   virtual std::string getAnnounceUrl();
 
-  virtual SharedHandle<UDPTrackerRequest>
+  virtual std::shared_ptr<UDPTrackerRequest>
   createUDPTrackerRequest(const std::string& remoteAddr, uint16_t remotePort,
                           uint16_t localPort);
 
@@ -123,7 +123,7 @@ public:
                                        size_t trackerResponseLength);
 
   virtual void processUDPTrackerResponse
-  (const SharedHandle<UDPTrackerRequest>& req);
+  (const std::shared_ptr<UDPTrackerRequest>& req);
 
   virtual bool noMoreAnnounce();
 
@@ -136,7 +136,7 @@ public:
     tcpPort_ = port;
   }
 
-  void setRandomizer(const SharedHandle<Randomizer>& randomizer);
+  void setRandomizer(const std::shared_ptr<Randomizer>& randomizer);
 
   time_t getInterval() const
   {
diff --git a/src/DefaultBtInteractive.cc b/src/DefaultBtInteractive.cc
index 42058c5f..61b8343d 100644
--- a/src/DefaultBtInteractive.cc
+++ b/src/DefaultBtInteractive.cc
@@ -77,8 +77,8 @@
 namespace aria2 {
 
 DefaultBtInteractive::DefaultBtInteractive
-(const SharedHandle<DownloadContext>& downloadContext,
- const SharedHandle<Peer>& peer)
+(const std::shared_ptr<DownloadContext>& downloadContext,
+ const std::shared_ptr<Peer>& peer)
   : cuid_(0),
     downloadContext_(downloadContext),
     peer_(peer),
@@ -104,18 +104,18 @@ DefaultBtInteractive::DefaultBtInteractive
 DefaultBtInteractive::~DefaultBtInteractive() {}
 
 void DefaultBtInteractive::initiateHandshake() {
-  SharedHandle<BtMessage> message =
+  std::shared_ptr<BtMessage> message =
     messageFactory_->createHandshakeMessage
     (bittorrent::getInfoHash(downloadContext_), bittorrent::getStaticPeerId());
   dispatcher_->addMessageToQueue(message);
   dispatcher_->sendMessages();
 }
 
-SharedHandle<BtMessage> DefaultBtInteractive::receiveHandshake(bool quickReply) {
-  SharedHandle<BtHandshakeMessage> message =
+std::shared_ptr<BtMessage> DefaultBtInteractive::receiveHandshake(bool quickReply) {
+  std::shared_ptr<BtHandshakeMessage> message =
     btMessageReceiver_->receiveHandshake(quickReply);
   if(!message) {
-    return SharedHandle<BtMessage>();
+    return std::shared_ptr<BtMessage>();
   }
   if(memcmp(message->getPeerId(), bittorrent::getStaticPeerId(),
             PEER_ID_LENGTH) == 0) {
@@ -158,7 +158,7 @@ SharedHandle<BtMessage> DefaultBtInteractive::receiveHandshake(bool quickReply)
   return message;
 }
 
-SharedHandle<BtMessage> DefaultBtInteractive::receiveAndSendHandshake() {
+std::shared_ptr<BtMessage> DefaultBtInteractive::receiveAndSendHandshake() {
   return receiveHandshake(true);
 }
 
@@ -191,16 +191,16 @@ void DefaultBtInteractive::addPortMessageToQueue()
 
 void DefaultBtInteractive::addHandshakeExtendedMessageToQueue()
 {
-  SharedHandle<HandshakeExtensionMessage> m(new HandshakeExtensionMessage());
+  std::shared_ptr<HandshakeExtensionMessage> m(new HandshakeExtensionMessage());
   m->setClientVersion("aria2/" PACKAGE_VERSION);
   m->setTCPPort(tcpPort_);
   m->setExtensions(extensionMessageRegistry_->getExtensions());
-  SharedHandle<TorrentAttribute> attrs =
+  std::shared_ptr<TorrentAttribute> attrs =
     bittorrent::getTorrentAttrs(downloadContext_);
   if(!attrs->metadata.empty()) {
     m->setMetadataSize(attrs->metadataSize);
   }
-  SharedHandle<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
+  std::shared_ptr<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
   dispatcher_->addMessageToQueue(msg);
 }
 
@@ -290,7 +290,7 @@ size_t DefaultBtInteractive::receiveMessages() {
        downloadContext_->getOwnerRequestGroup()->doesDownloadSpeedExceed()) {
       break;
     }
-    SharedHandle<BtMessage> message = btMessageReceiver_->receiveMessage();
+    std::shared_ptr<BtMessage> message = btMessageReceiver_->receiveMessage();
     if(!message) {
       break;
     }
@@ -356,7 +356,7 @@ void DefaultBtInteractive::fillPiece(size_t maxMissingBlock) {
       return;
     }
     size_t diffMissingBlock = maxMissingBlock-numMissingBlock;
-    std::vector<SharedHandle<Piece> > pieces;
+    std::vector<std::shared_ptr<Piece> > pieces;
     if(peer_->peerChoking()) {
       if(peer_->isFastExtensionEnabled()) {
         if(pieceStorage_->isEndGame()) {
@@ -383,7 +383,7 @@ void DefaultBtInteractive::fillPiece(size_t maxMissingBlock) {
         pieceStorage_->getMissingPiece(pieces, diffMissingBlock, peer_, cuid_);
       }
     }
-    for(std::vector<SharedHandle<Piece> >::const_iterator i =
+    for(std::vector<std::shared_ptr<Piece> >::const_iterator i =
           pieces.begin(), eoi = pieces.end(); i != eoi; ++i) {
       btRequestFactory_->addTargetPiece(*i);
     }
@@ -400,7 +400,7 @@ void DefaultBtInteractive::addRequests() {
     0 : maxOutstandingRequest_-dispatcher_->countOutstandingRequest();
 
   if(reqNumToCreate > 0) {
-    std::vector<SharedHandle<BtMessage> > requests;
+    std::vector<std::shared_ptr<BtMessage> > requests;
     requests.reserve(reqNumToCreate);
     if(pieceStorage_->isEndGame()) {
       btRequestFactory_->createRequestMessagesOnEndGame(requests,reqNumToCreate);
@@ -481,7 +481,7 @@ void DefaultBtInteractive::addPeerExchangeMessage()
 {
   if(pexTimer_.
      difference(global::wallclock()) >= UTPexExtensionMessage::DEFAULT_INTERVAL) {
-    SharedHandle<UTPexExtensionMessage> m
+    std::shared_ptr<UTPexExtensionMessage> m
       (new UTPexExtensionMessage(peer_->getExtensionMessageID
                                  (ExtensionMessageRegistry::UT_PEX)));
 
@@ -492,9 +492,9 @@ void DefaultBtInteractive::addPeerExchangeMessage()
         m->addFreshPeer(*i);
       }
     }
-    const std::deque<SharedHandle<Peer> >& droppedPeers =
+    const std::deque<std::shared_ptr<Peer> >& droppedPeers =
       peerStorage_->getDroppedPeers();
-    for(std::deque<SharedHandle<Peer> >::const_iterator i =
+    for(std::deque<std::shared_ptr<Peer> >::const_iterator i =
           droppedPeers.begin(), eoi = droppedPeers.end();
         i != eoi && !m->droppedPeersAreFull();
         ++i) {
@@ -503,7 +503,7 @@ void DefaultBtInteractive::addPeerExchangeMessage()
       }
     }
 
-    SharedHandle<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
+    std::shared_ptr<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
     dispatcher_->addMessageToQueue(msg);
     pexTimer_ = global::wallclock();
   }
@@ -521,7 +521,7 @@ void DefaultBtInteractive::doInteractionProcessing() {
        downloadContext_->getTotalLength() > 0) {
       size_t num = utMetadataRequestTracker_->avail();
       if(num > 0) {
-        std::vector<SharedHandle<BtMessage> > requests;
+        std::vector<std::shared_ptr<BtMessage> > requests;
         utMetadataRequestFactory_->create(requests, num, pieceStorage_);
         dispatcher_->addMessageToQueue(requests);
       }
@@ -596,60 +596,60 @@ size_t DefaultBtInteractive::countOutstandingRequest()
 }
 
 void DefaultBtInteractive::setBtRuntime
-(const SharedHandle<BtRuntime>& btRuntime)
+(const std::shared_ptr<BtRuntime>& btRuntime)
 {
   btRuntime_ = btRuntime;
 }
 
 void DefaultBtInteractive::setPieceStorage
-(const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
 
 void DefaultBtInteractive::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
 
-void DefaultBtInteractive::setPeer(const SharedHandle<Peer>& peer)
+void DefaultBtInteractive::setPeer(const std::shared_ptr<Peer>& peer)
 {
   peer_ = peer;
 }
 
 void DefaultBtInteractive::setBtMessageReceiver
-(const SharedHandle<BtMessageReceiver>& receiver)
+(const std::shared_ptr<BtMessageReceiver>& receiver)
 {
   btMessageReceiver_ = receiver;
 }
 
 void DefaultBtInteractive::setDispatcher
-(const SharedHandle<BtMessageDispatcher>& dispatcher)
+(const std::shared_ptr<BtMessageDispatcher>& dispatcher)
 {
   dispatcher_ = dispatcher;
 }
 
 void DefaultBtInteractive::setBtRequestFactory
-(const SharedHandle<BtRequestFactory>& factory)
+(const std::shared_ptr<BtRequestFactory>& factory)
 {
   btRequestFactory_ = factory;
 }
 
 void DefaultBtInteractive::setPeerConnection
-(const SharedHandle<PeerConnection>& peerConnection)
+(const std::shared_ptr<PeerConnection>& peerConnection)
 {
   peerConnection_ = peerConnection;
 }
 
 void DefaultBtInteractive::setExtensionMessageFactory
-(const SharedHandle<ExtensionMessageFactory>& factory)
+(const std::shared_ptr<ExtensionMessageFactory>& factory)
 {
   extensionMessageFactory_ = factory;
 }
 
 void DefaultBtInteractive::setBtMessageFactory
-(const SharedHandle<BtMessageFactory>& factory)
+(const std::shared_ptr<BtMessageFactory>& factory)
 {
   messageFactory_ = factory;
 }
diff --git a/src/DefaultBtInteractive.h b/src/DefaultBtInteractive.h
index c96b8663..d64227d1 100644
--- a/src/DefaultBtInteractive.h
+++ b/src/DefaultBtInteractive.h
@@ -100,27 +100,27 @@ class DefaultBtInteractive : public BtInteractive {
 private:
   cuid_t cuid_;
 
-  SharedHandle<DownloadContext> downloadContext_;
+  std::shared_ptr<DownloadContext> downloadContext_;
 
-  SharedHandle<BtRuntime> btRuntime_;
+  std::shared_ptr<BtRuntime> btRuntime_;
 
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
 
-  SharedHandle<PeerStorage> peerStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
 
-  SharedHandle<Peer> peer_;
+  std::shared_ptr<Peer> peer_;
 
-  SharedHandle<BtMessageReceiver> btMessageReceiver_;
-  SharedHandle<BtMessageDispatcher> dispatcher_;
-  SharedHandle<BtRequestFactory> btRequestFactory_;
+  std::shared_ptr<BtMessageReceiver> btMessageReceiver_;
+  std::shared_ptr<BtMessageDispatcher> dispatcher_;
+  std::shared_ptr<BtRequestFactory> btRequestFactory_;
   // Although peerStorage_ is not used in this class, this object
   // holds the reference so that peerConnection_ is not deleted.
-  SharedHandle<PeerConnection> peerConnection_;
-  SharedHandle<BtMessageFactory> messageFactory_;
-  SharedHandle<ExtensionMessageFactory> extensionMessageFactory_;
-  SharedHandle<ExtensionMessageRegistry> extensionMessageRegistry_;
-  SharedHandle<UTMetadataRequestFactory> utMetadataRequestFactory_;
-  SharedHandle<UTMetadataRequestTracker> utMetadataRequestTracker_;
+  std::shared_ptr<PeerConnection> peerConnection_;
+  std::shared_ptr<BtMessageFactory> messageFactory_;
+  std::shared_ptr<ExtensionMessageFactory> extensionMessageFactory_;
+  std::shared_ptr<ExtensionMessageRegistry> extensionMessageRegistry_;
+  std::shared_ptr<UTMetadataRequestFactory> utMetadataRequestFactory_;
+  std::shared_ptr<UTMetadataRequestTracker> utMetadataRequestTracker_;
 
   bool metadataGetMode_;
 
@@ -166,16 +166,16 @@ private:
   void addPortMessageToQueue();
 
 public:
-  DefaultBtInteractive(const SharedHandle<DownloadContext>& downloadContext,
-                       const SharedHandle<Peer>& peer);
+  DefaultBtInteractive(const std::shared_ptr<DownloadContext>& downloadContext,
+                       const std::shared_ptr<Peer>& peer);
 
   virtual ~DefaultBtInteractive();
 
   virtual void initiateHandshake();
 
-  virtual SharedHandle<BtMessage> receiveHandshake(bool quickReply = false);
+  virtual std::shared_ptr<BtMessage> receiveHandshake(bool quickReply = false);
 
-  virtual SharedHandle<BtMessage> receiveAndSendHandshake();
+  virtual std::shared_ptr<BtMessage> receiveAndSendHandshake();
 
   virtual void doPostHandshakeProcessing();
 
@@ -200,29 +200,29 @@ public:
     cuid_ = cuid;
   }
 
-  void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime);
+  void setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime);
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 
-  void setPeer(const SharedHandle<Peer>& peer);
+  void setPeer(const std::shared_ptr<Peer>& peer);
 
-  void setBtMessageReceiver(const SharedHandle<BtMessageReceiver>& receiver);
+  void setBtMessageReceiver(const std::shared_ptr<BtMessageReceiver>& receiver);
 
-  void setDispatcher(const SharedHandle<BtMessageDispatcher>& dispatcher);
+  void setDispatcher(const std::shared_ptr<BtMessageDispatcher>& dispatcher);
 
-  void setBtRequestFactory(const SharedHandle<BtRequestFactory>& factory);
+  void setBtRequestFactory(const std::shared_ptr<BtRequestFactory>& factory);
 
-  void setPeerConnection(const SharedHandle<PeerConnection>& peerConnection);
+  void setPeerConnection(const std::shared_ptr<PeerConnection>& peerConnection);
 
-  void setBtMessageFactory(const SharedHandle<BtMessageFactory>& factory);
+  void setBtMessageFactory(const std::shared_ptr<BtMessageFactory>& factory);
 
   void setExtensionMessageFactory
-  (const SharedHandle<ExtensionMessageFactory>& factory);
+  (const std::shared_ptr<ExtensionMessageFactory>& factory);
 
   void setExtensionMessageRegistry
-  (const SharedHandle<ExtensionMessageRegistry>& registry)
+  (const std::shared_ptr<ExtensionMessageRegistry>& registry)
   {
     extensionMessageRegistry_ = registry;
   }
@@ -246,13 +246,13 @@ public:
   void setRequestGroupMan(RequestGroupMan* rgman);
 
   void setUTMetadataRequestTracker
-  (const SharedHandle<UTMetadataRequestTracker>& tracker)
+  (const std::shared_ptr<UTMetadataRequestTracker>& tracker)
   {
     utMetadataRequestTracker_ = tracker;
   }
 
   void setUTMetadataRequestFactory
-  (const SharedHandle<UTMetadataRequestFactory>& factory)
+  (const std::shared_ptr<UTMetadataRequestFactory>& factory)
   {
     utMetadataRequestFactory_ = factory;
   }
diff --git a/src/DefaultBtMessageDispatcher.cc b/src/DefaultBtMessageDispatcher.cc
index bc236350..ac7d4d8a 100644
--- a/src/DefaultBtMessageDispatcher.cc
+++ b/src/DefaultBtMessageDispatcher.cc
@@ -73,16 +73,16 @@ DefaultBtMessageDispatcher::~DefaultBtMessageDispatcher()
 }
 
 void DefaultBtMessageDispatcher::addMessageToQueue
-(const SharedHandle<BtMessage>& btMessage)
+(const std::shared_ptr<BtMessage>& btMessage)
 {
   btMessage->onQueued();
   messageQueue_.push_back(btMessage);
 }
 
 void DefaultBtMessageDispatcher::addMessageToQueue
-(const std::vector<SharedHandle<BtMessage> >& btMessages)
+(const std::vector<std::shared_ptr<BtMessage> >& btMessages)
 {
-  for(std::vector<SharedHandle<BtMessage> >::const_iterator itr =
+  for(std::vector<std::shared_ptr<BtMessage> >::const_iterator itr =
         btMessages.begin(), eoi = btMessages.end(); itr != eoi; ++itr) {
     addMessageToQueue(*itr);
   }
@@ -90,9 +90,9 @@ void DefaultBtMessageDispatcher::addMessageToQueue
 
 void DefaultBtMessageDispatcher::sendMessagesInternal()
 {
-  std::vector<SharedHandle<BtMessage> > tempQueue;
+  std::vector<std::shared_ptr<BtMessage> > tempQueue;
   while(!messageQueue_.empty()) {
-    SharedHandle<BtMessage> msg = messageQueue_.front();
+    std::shared_ptr<BtMessage> msg = messageQueue_.front();
     messageQueue_.pop_front();
     if(msg->isUploading()) {
       if(requestGroupMan_->doesOverallUploadSpeedExceed() ||
@@ -123,7 +123,7 @@ void DefaultBtMessageDispatcher::doCancelSendingPieceAction
 {
   BtCancelSendingPieceEvent event(index, begin, length);
 
-  std::vector<SharedHandle<BtMessage> > tempQueue
+  std::vector<std::shared_ptr<BtMessage> > tempQueue
     (messageQueue_.begin(), messageQueue_.end());
 
   forEachMemFunSH(tempQueue.begin(), tempQueue.end(),
@@ -133,13 +133,13 @@ void DefaultBtMessageDispatcher::doCancelSendingPieceAction
 // Cancel sending piece message to peer.
 // TODO Is this method really necessary?
 void DefaultBtMessageDispatcher::doCancelSendingPieceAction
-(const SharedHandle<Piece>& piece)
+(const std::shared_ptr<Piece>& piece)
 {
 }
 
 namespace {
 void abortOutstandingRequest
-(const RequestSlot& slot, const SharedHandle<Piece>& piece, cuid_t cuid)
+(const RequestSlot& slot, const std::shared_ptr<Piece>& piece, cuid_t cuid)
 {
   A2_LOG_DEBUG(fmt(MSG_DELETING_REQUEST_SLOT,
                    cuid,
@@ -163,7 +163,7 @@ struct FindRequestSlotByIndex {
 
 // localhost cancels outstanding download requests to the peer.
 void DefaultBtMessageDispatcher::doAbortOutstandingRequestAction
-(const SharedHandle<Piece>& piece) {
+(const std::shared_ptr<Piece>& piece) {
   for(std::deque<RequestSlot>::iterator itr = requestSlots_.begin(),
         eoi = requestSlots_.end(); itr != eoi; ++itr) {
     if((*itr).getIndex() == piece->getIndex()) {
@@ -176,7 +176,7 @@ void DefaultBtMessageDispatcher::doAbortOutstandingRequestAction
 
   BtAbortOutstandingRequestEvent event(piece);
 
-  std::vector<SharedHandle<BtMessage> > tempQueue
+  std::vector<std::shared_ptr<BtMessage> > tempQueue
     (messageQueue_.begin(), messageQueue_.end());
   forEachMemFunSH(tempQueue.begin(), tempQueue.end(),
                   &BtMessage::onAbortOutstandingRequestEvent, event);
@@ -186,13 +186,13 @@ namespace {
 class ProcessChokedRequestSlot {
 private:
   cuid_t cuid_;
-  SharedHandle<Peer> peer_;
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<Peer> peer_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
 public:
   ProcessChokedRequestSlot
   (cuid_t cuid,
-   const SharedHandle<Peer>& peer,
-   const SharedHandle<PieceStorage>& pieceStorage)
+   const std::shared_ptr<Peer>& peer,
+   const std::shared_ptr<PieceStorage>& pieceStorage)
     : cuid_(cuid),
       peer_(peer),
       pieceStorage_(pieceStorage)
@@ -206,7 +206,7 @@ public:
                        static_cast<unsigned long>(slot.getIndex()),
                        slot.getBegin(),
                        static_cast<unsigned long>(slot.getBlockIndex())));
-      SharedHandle<Piece> piece = pieceStorage_->getPiece(slot.getIndex());
+      std::shared_ptr<Piece> piece = pieceStorage_->getPiece(slot.getIndex());
       piece->cancelBlock(slot.getBlockIndex());
     }
   }
@@ -217,9 +217,9 @@ public:
 namespace {
 class FindChokedRequestSlot {
 private:
-  SharedHandle<Peer> peer_;
+  std::shared_ptr<Peer> peer_;
 public:
-  FindChokedRequestSlot(const SharedHandle<Peer>& peer):
+  FindChokedRequestSlot(const std::shared_ptr<Peer>& peer):
     peer_(peer) {}
 
   bool operator()(const RequestSlot& slot) const
@@ -245,7 +245,7 @@ void DefaultBtMessageDispatcher::doChokingAction()
 {
   BtChokingEvent event;
 
-  std::vector<SharedHandle<BtMessage> > tempQueue
+  std::vector<std::shared_ptr<BtMessage> > tempQueue
     (messageQueue_.begin(), messageQueue_.end());
   forEachMemFunSH(tempQueue.begin(), tempQueue.end(),
                   &BtMessage::onChokingEvent, event);
@@ -255,15 +255,15 @@ namespace {
 class ProcessStaleRequestSlot {
 private:
   cuid_t cuid_;
-  SharedHandle<Peer> peer_;
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<Peer> peer_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
   BtMessageDispatcher* messageDispatcher_;
   BtMessageFactory* messageFactory_;
   time_t requestTimeout_;
 public:
   ProcessStaleRequestSlot
-  (cuid_t cuid, const SharedHandle<Peer>& peer,
-   const SharedHandle<PieceStorage>& pieceStorage,
+  (cuid_t cuid, const std::shared_ptr<Peer>& peer,
+   const std::shared_ptr<PieceStorage>& pieceStorage,
    BtMessageDispatcher* dispatcher,
    BtMessageFactory* factory,
    time_t requestTimeout)
@@ -303,10 +303,10 @@ public:
 namespace {
 class FindStaleRequestSlot {
 private:
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
   time_t requestTimeout_;
 public:
-  FindStaleRequestSlot(const SharedHandle<PieceStorage>& pieceStorage,
+  FindStaleRequestSlot(const std::shared_ptr<PieceStorage>& pieceStorage,
                        time_t requestTimeout):
     pieceStorage_(pieceStorage),
     requestTimeout_(requestTimeout) {}
@@ -411,25 +411,25 @@ size_t DefaultBtMessageDispatcher::countOutstandingUpload()
                        mem_fun_sh(&BtMessage::isUploading));
 }
 
-void DefaultBtMessageDispatcher::setPeer(const SharedHandle<Peer>& peer)
+void DefaultBtMessageDispatcher::setPeer(const std::shared_ptr<Peer>& peer)
 {
   peer_ = peer;
 }
 
 void DefaultBtMessageDispatcher::setDownloadContext
-(const SharedHandle<DownloadContext>& downloadContext)
+(const std::shared_ptr<DownloadContext>& downloadContext)
 {
   downloadContext_ = downloadContext;
 }
 
 void DefaultBtMessageDispatcher::setPieceStorage
-(const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
 
 void DefaultBtMessageDispatcher::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
diff --git a/src/DefaultBtMessageDispatcher.h b/src/DefaultBtMessageDispatcher.h
index 7a8c44e1..96fefdf7 100644
--- a/src/DefaultBtMessageDispatcher.h
+++ b/src/DefaultBtMessageDispatcher.h
@@ -57,14 +57,14 @@ class PeerConnection;
 class DefaultBtMessageDispatcher : public BtMessageDispatcher {
 private:
   cuid_t cuid_;
-  std::deque<SharedHandle<BtMessage> > messageQueue_;
+  std::deque<std::shared_ptr<BtMessage> > messageQueue_;
   std::deque<RequestSlot> requestSlots_;
-  SharedHandle<DownloadContext> downloadContext_;
-  SharedHandle<PeerStorage> peerStorage_;
-  SharedHandle<PieceStorage> pieceStorage_;
-  SharedHandle<PeerConnection> peerConnection_;
+  std::shared_ptr<DownloadContext> downloadContext_;
+  std::shared_ptr<PeerStorage> peerStorage_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
+  std::shared_ptr<PeerConnection> peerConnection_;
   BtMessageFactory* messageFactory_;
-  SharedHandle<Peer> peer_;
+  std::shared_ptr<Peer> peer_;
   RequestGroupMan* requestGroupMan_;
   time_t requestTimeout_;
 public:
@@ -72,10 +72,10 @@ public:
 
   virtual ~DefaultBtMessageDispatcher();
 
-  virtual void addMessageToQueue(const SharedHandle<BtMessage>& btMessage);
+  virtual void addMessageToQueue(const std::shared_ptr<BtMessage>& btMessage);
 
   virtual void addMessageToQueue
-  (const std::vector<SharedHandle<BtMessage> >& btMessages);
+  (const std::vector<std::shared_ptr<BtMessage> >& btMessages);
 
   virtual void sendMessages();
 
@@ -85,9 +85,9 @@ public:
   virtual void doCancelSendingPieceAction
   (size_t index, int32_t begin, int32_t length);
 
-  virtual void doCancelSendingPieceAction(const SharedHandle<Piece>& piece);
+  virtual void doCancelSendingPieceAction(const std::shared_ptr<Piece>& piece);
 
-  virtual void doAbortOutstandingRequestAction(const SharedHandle<Piece>& piece);
+  virtual void doAbortOutstandingRequestAction(const std::shared_ptr<Piece>& piece);
 
   virtual void doChokedAction();
 
@@ -117,7 +117,7 @@ public:
 
   virtual size_t countOutstandingUpload();
 
-  const std::deque<SharedHandle<BtMessage> >& getMessageQueue() const
+  const std::deque<std::shared_ptr<BtMessage> >& getMessageQueue() const
   {
     return messageQueue_;
   }
@@ -127,13 +127,13 @@ public:
     return requestSlots_;
   }
 
-  void setPeer(const SharedHandle<Peer>& peer);
+  void setPeer(const std::shared_ptr<Peer>& peer);
 
-  void setDownloadContext(const SharedHandle<DownloadContext>& downloadContext);
+  void setDownloadContext(const std::shared_ptr<DownloadContext>& downloadContext);
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 
   void setBtMessageFactory(BtMessageFactory* factory);
 
@@ -149,7 +149,7 @@ public:
     requestTimeout_ = requestTimeout;
   }
 
-  void setPeerConnection(const SharedHandle<PeerConnection>& peerConnection)
+  void setPeerConnection(const std::shared_ptr<PeerConnection>& peerConnection)
   {
     peerConnection_ = peerConnection;
   }
diff --git a/src/DefaultBtMessageFactory.cc b/src/DefaultBtMessageFactory.cc
index e2666fa5..6abe6445 100644
--- a/src/DefaultBtMessageFactory.cc
+++ b/src/DefaultBtMessageFactory.cc
@@ -85,11 +85,11 @@ DefaultBtMessageFactory::DefaultBtMessageFactory():
 
 DefaultBtMessageFactory::~DefaultBtMessageFactory() {}
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createBtMessage
 (const unsigned char* data, size_t dataLength)
 {
-  SharedHandle<AbstractBtMessage> msg;
+  std::shared_ptr<AbstractBtMessage> msg;
   if(dataLength == 0) {
     // keep-alive
     msg.reset(new BtKeepAliveMessage());
@@ -120,7 +120,7 @@ DefaultBtMessageFactory::createBtMessage
     case BtHaveMessage::ID:
       msg.reset(BtHaveMessage::create(data, dataLength));
       if(!metadataGetMode_) {
-        SharedHandle<BtMessageValidator> v
+        std::shared_ptr<BtMessageValidator> v
           (new IndexBtMessageValidator(static_cast<BtHaveMessage*>(msg.get()),
                                        downloadContext_->getNumPieces()));
         msg->setBtMessageValidator(v);
@@ -129,7 +129,7 @@ DefaultBtMessageFactory::createBtMessage
     case BtBitfieldMessage::ID:
       msg.reset(BtBitfieldMessage::create(data, dataLength));
       if(!metadataGetMode_) {
-        SharedHandle<BtMessageValidator> v
+        std::shared_ptr<BtMessageValidator> v
           (new BtBitfieldMessageValidator
            (static_cast<BtBitfieldMessage*>(msg.get()),
             downloadContext_->getNumPieces()));
@@ -139,7 +139,7 @@ DefaultBtMessageFactory::createBtMessage
     case BtRequestMessage::ID: {
       BtRequestMessage* m = BtRequestMessage::create(data, dataLength);
       if(!metadataGetMode_) {
-        SharedHandle<BtMessageValidator> validator
+        std::shared_ptr<BtMessageValidator> validator
           (new RangeBtMessageValidator
            (m,
             downloadContext_->getNumPieces(),
@@ -152,7 +152,7 @@ DefaultBtMessageFactory::createBtMessage
     case BtCancelMessage::ID: {
       BtCancelMessage* m = BtCancelMessage::create(data, dataLength);
       if(!metadataGetMode_) {
-        SharedHandle<BtMessageValidator> validator
+        std::shared_ptr<BtMessageValidator> validator
           (new RangeBtMessageValidator
            (m,
             downloadContext_->getNumPieces(),
@@ -165,7 +165,7 @@ DefaultBtMessageFactory::createBtMessage
     case BtPieceMessage::ID: {
       BtPieceMessage* m = BtPieceMessage::create(data, dataLength);
       if(!metadataGetMode_) {
-        SharedHandle<BtMessageValidator> validator
+        std::shared_ptr<BtMessageValidator> validator
           (new BtPieceMessageValidator
            (m,
             downloadContext_->getNumPieces(),
@@ -186,7 +186,7 @@ DefaultBtMessageFactory::createBtMessage
     case BtRejectMessage::ID: {
       BtRejectMessage* m = BtRejectMessage::create(data, dataLength);
       if(!metadataGetMode_) {
-        SharedHandle<BtMessageValidator> validator
+        std::shared_ptr<BtMessageValidator> validator
           (new RangeBtMessageValidator
            (m,
             downloadContext_->getNumPieces(),
@@ -200,7 +200,7 @@ DefaultBtMessageFactory::createBtMessage
       BtSuggestPieceMessage* m =
         BtSuggestPieceMessage::create(data, dataLength);
       if(!metadataGetMode_) {
-        SharedHandle<BtMessageValidator> validator
+        std::shared_ptr<BtMessageValidator> validator
           (new IndexBtMessageValidator(m, downloadContext_->getNumPieces()));
         m->setBtMessageValidator(validator);
       }
@@ -210,7 +210,7 @@ DefaultBtMessageFactory::createBtMessage
     case BtAllowedFastMessage::ID: {
       BtAllowedFastMessage* m = BtAllowedFastMessage::create(data, dataLength);
       if(!metadataGetMode_) {
-        SharedHandle<BtMessageValidator> validator
+        std::shared_ptr<BtMessageValidator> validator
           (new IndexBtMessageValidator(m, downloadContext_->getNumPieces()));
         m->setBtMessageValidator(validator);
       }
@@ -258,13 +258,13 @@ void DefaultBtMessageFactory::setCommonProperty(AbstractBtMessage* msg)
   }
 }
 
-SharedHandle<BtHandshakeMessage>
+std::shared_ptr<BtHandshakeMessage>
 DefaultBtMessageFactory::createHandshakeMessage
 (const unsigned char* data, size_t dataLength)
 {
-  SharedHandle<BtHandshakeMessage> msg =
+  std::shared_ptr<BtHandshakeMessage> msg =
     BtHandshakeMessage::create(data, dataLength);
-  SharedHandle<BtMessageValidator> validator
+  std::shared_ptr<BtMessageValidator> validator
     (new BtHandshakeMessageValidator
      (msg.get(), bittorrent::getInfoHash(downloadContext_)));
   msg->setBtMessageValidator(validator);
@@ -272,20 +272,20 @@ DefaultBtMessageFactory::createHandshakeMessage
   return msg;
 }
 
-SharedHandle<BtHandshakeMessage>
+std::shared_ptr<BtHandshakeMessage>
 DefaultBtMessageFactory::createHandshakeMessage(const unsigned char* infoHash,
                                                 const unsigned char* peerId)
 {
-  SharedHandle<BtHandshakeMessage> msg
+  std::shared_ptr<BtHandshakeMessage> msg
     (new BtHandshakeMessage(infoHash, peerId));
   msg->setDHTEnabled(dhtEnabled_);
   setCommonProperty(msg.get());
   return msg;
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createRequestMessage
-(const SharedHandle<Piece>& piece, size_t blockIndex)
+(const std::shared_ptr<Piece>& piece, size_t blockIndex)
 {
   BtRequestMessage* msg
     (new BtRequestMessage(piece->getIndex(),
@@ -293,134 +293,134 @@ DefaultBtMessageFactory::createRequestMessage
                           piece->getBlockLength(blockIndex),
                           blockIndex));
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createCancelMessage
 (size_t index, int32_t begin, int32_t length)
 {
   BtCancelMessage* msg(new BtCancelMessage(index, begin, length));
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createPieceMessage
 (size_t index, int32_t begin, int32_t length)
 {
   BtPieceMessage* msg(new BtPieceMessage(index, begin, length));
   msg->setDownloadContext(downloadContext_);
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createHaveMessage(size_t index)
 {
   BtHaveMessage* msg(new BtHaveMessage(index));
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createChokeMessage()
 {
   BtChokeMessage* msg(new BtChokeMessage());
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createUnchokeMessage()
 {
   BtUnchokeMessage* msg(new BtUnchokeMessage());
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createInterestedMessage()
 {
   BtInterestedMessage* msg(new BtInterestedMessage());
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createNotInterestedMessage()
 {
   BtNotInterestedMessage* msg(new BtNotInterestedMessage());
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createBitfieldMessage()
 {
   BtBitfieldMessage* msg
     (new BtBitfieldMessage(pieceStorage_->getBitfield(),
                            pieceStorage_->getBitfieldLength()));
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createKeepAliveMessage()
 {
   BtKeepAliveMessage* msg(new BtKeepAliveMessage());
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createHaveAllMessage()
 {
   BtHaveAllMessage* msg(new BtHaveAllMessage());
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createHaveNoneMessage()
 {
   BtHaveNoneMessage* msg(new BtHaveNoneMessage());
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createRejectMessage
 (size_t index, int32_t begin, int32_t length)
 {
   BtRejectMessage* msg(new BtRejectMessage(index, begin, length));
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createAllowedFastMessage(size_t index)
 {
   BtAllowedFastMessage* msg(new BtAllowedFastMessage(index));
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createPortMessage(uint16_t port)
 {
   BtPortMessage* msg(new BtPortMessage(port));
   setCommonProperty(msg);
-  return SharedHandle<BtMessage>(msg);
+  return std::shared_ptr<BtMessage>(msg);
 }
 
-SharedHandle<BtMessage>
+std::shared_ptr<BtMessage>
 DefaultBtMessageFactory::createBtExtendedMessage
-(const SharedHandle<ExtensionMessage>& msg)
+(const std::shared_ptr<ExtensionMessage>& msg)
 {
   BtExtendedMessage* m(new BtExtendedMessage(msg));
   setCommonProperty(m);
-  return SharedHandle<BtMessage>(m);
+  return std::shared_ptr<BtMessage>(m);
 }
 
 void DefaultBtMessageFactory::setTaskQueue(DHTTaskQueue* taskQueue)
@@ -433,25 +433,25 @@ void DefaultBtMessageFactory::setTaskFactory(DHTTaskFactory* taskFactory)
   taskFactory_ = taskFactory;
 }
 
-void DefaultBtMessageFactory::setPeer(const SharedHandle<Peer>& peer)
+void DefaultBtMessageFactory::setPeer(const std::shared_ptr<Peer>& peer)
 {
   peer_ = peer;
 }
 
 void DefaultBtMessageFactory::setDownloadContext
-(const SharedHandle<DownloadContext>& downloadContext)
+(const std::shared_ptr<DownloadContext>& downloadContext)
 {
   downloadContext_ = downloadContext;
 }
 
 void DefaultBtMessageFactory::setPieceStorage
-(const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
 
 void DefaultBtMessageFactory::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
@@ -463,7 +463,7 @@ void DefaultBtMessageFactory::setBtMessageDispatcher
 }
 
 void DefaultBtMessageFactory::setExtensionMessageFactory
-(const SharedHandle<ExtensionMessageFactory>& factory)
+(const std::shared_ptr<ExtensionMessageFactory>& factory)
 {
   extensionMessageFactory_ = factory;
 }
diff --git a/src/DefaultBtMessageFactory.h b/src/DefaultBtMessageFactory.h
index c6875e6d..df9c08d7 100644
--- a/src/DefaultBtMessageFactory.h
+++ b/src/DefaultBtMessageFactory.h
@@ -57,10 +57,10 @@ class DHTTaskFactory;
 class DefaultBtMessageFactory : public BtMessageFactory {
 private:
   cuid_t cuid_;
-  SharedHandle<DownloadContext> downloadContext_;
-  SharedHandle<PieceStorage> pieceStorage_;
-  SharedHandle<PeerStorage> peerStorage_;
-  SharedHandle<Peer> peer_;
+  std::shared_ptr<DownloadContext> downloadContext_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
+  std::shared_ptr<Peer> peer_;
 
   bool dhtEnabled_;
 
@@ -70,7 +70,7 @@ private:
 
   PeerConnection* peerConnection_;
 
-  SharedHandle<ExtensionMessageFactory> extensionMessageFactory_;
+  std::shared_ptr<ExtensionMessageFactory> extensionMessageFactory_;
 
   DHTNode* localNode_;
 
@@ -88,60 +88,60 @@ public:
 
   virtual ~DefaultBtMessageFactory();
 
-  virtual SharedHandle<BtMessage>
+  virtual std::shared_ptr<BtMessage>
   createBtMessage(const unsigned char* msg, size_t msgLength);
 
-  virtual SharedHandle<BtHandshakeMessage>
+  virtual std::shared_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* msg, size_t msgLength);
 
-  virtual SharedHandle<BtHandshakeMessage>
+  virtual std::shared_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* infoHash,
                          const unsigned char* peerId);
 
-  virtual SharedHandle<BtMessage>
-  createRequestMessage(const SharedHandle<Piece>& piece, size_t blockIndex);
+  virtual std::shared_ptr<BtMessage>
+  createRequestMessage(const std::shared_ptr<Piece>& piece, size_t blockIndex);
 
-  virtual SharedHandle<BtMessage>
+  virtual std::shared_ptr<BtMessage>
   createCancelMessage(size_t index, int32_t begin, int32_t length);
 
-  virtual SharedHandle<BtMessage>
+  virtual std::shared_ptr<BtMessage>
   createPieceMessage(size_t index, int32_t begin, int32_t length);
 
-  virtual SharedHandle<BtMessage> createHaveMessage(size_t index);
+  virtual std::shared_ptr<BtMessage> createHaveMessage(size_t index);
 
-  virtual SharedHandle<BtMessage> createChokeMessage();
+  virtual std::shared_ptr<BtMessage> createChokeMessage();
 
-  virtual SharedHandle<BtMessage> createUnchokeMessage();
+  virtual std::shared_ptr<BtMessage> createUnchokeMessage();
 
-  virtual SharedHandle<BtMessage> createInterestedMessage();
+  virtual std::shared_ptr<BtMessage> createInterestedMessage();
 
-  virtual SharedHandle<BtMessage> createNotInterestedMessage();
+  virtual std::shared_ptr<BtMessage> createNotInterestedMessage();
 
-  virtual SharedHandle<BtMessage> createBitfieldMessage();
+  virtual std::shared_ptr<BtMessage> createBitfieldMessage();
 
-  virtual SharedHandle<BtMessage> createKeepAliveMessage();
+  virtual std::shared_ptr<BtMessage> createKeepAliveMessage();
 
-  virtual SharedHandle<BtMessage> createHaveAllMessage();
+  virtual std::shared_ptr<BtMessage> createHaveAllMessage();
 
-  virtual SharedHandle<BtMessage> createHaveNoneMessage();
+  virtual std::shared_ptr<BtMessage> createHaveNoneMessage();
 
-  virtual SharedHandle<BtMessage>
+  virtual std::shared_ptr<BtMessage>
   createRejectMessage(size_t index, int32_t begin, int32_t length);
 
-  virtual SharedHandle<BtMessage> createAllowedFastMessage(size_t index);
+  virtual std::shared_ptr<BtMessage> createAllowedFastMessage(size_t index);
 
-  virtual SharedHandle<BtMessage> createPortMessage(uint16_t port);
+  virtual std::shared_ptr<BtMessage> createPortMessage(uint16_t port);
 
-  virtual SharedHandle<BtMessage>
-  createBtExtendedMessage(const SharedHandle<ExtensionMessage>& msg);
+  virtual std::shared_ptr<BtMessage>
+  createBtExtendedMessage(const std::shared_ptr<ExtensionMessage>& msg);
 
-  void setPeer(const SharedHandle<Peer>& peer);
+  void setPeer(const std::shared_ptr<Peer>& peer);
 
-  void setDownloadContext(const SharedHandle<DownloadContext>& downloadContext);
+  void setDownloadContext(const std::shared_ptr<DownloadContext>& downloadContext);
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 
   void setCuid(cuid_t cuid)
   {
@@ -160,7 +160,7 @@ public:
   void setPeerConnection(PeerConnection* connection);
 
   void setExtensionMessageFactory
-  (const SharedHandle<ExtensionMessageFactory>& factory);
+  (const std::shared_ptr<ExtensionMessageFactory>& factory);
 
   void setLocalNode(DHTNode* localNode);
 
diff --git a/src/DefaultBtMessageReceiver.cc b/src/DefaultBtMessageReceiver.cc
index ae406657..1e90f016 100644
--- a/src/DefaultBtMessageReceiver.cc
+++ b/src/DefaultBtMessageReceiver.cc
@@ -60,7 +60,7 @@ DefaultBtMessageReceiver::DefaultBtMessageReceiver():
   messageFactory_(0)
 {}
 
-SharedHandle<BtHandshakeMessage>
+std::shared_ptr<BtHandshakeMessage>
 DefaultBtMessageReceiver::receiveHandshake(bool quickReply)
 {
   A2_LOG_DEBUG
@@ -68,7 +68,7 @@ DefaultBtMessageReceiver::receiveHandshake(bool quickReply)
          static_cast<unsigned long>(peerConnection_->getBufferLength())));
   unsigned char data[BtHandshakeMessage::MESSAGE_LENGTH];
   size_t dataLength = BtHandshakeMessage::MESSAGE_LENGTH;
-  SharedHandle<BtHandshakeMessage> msg;
+  std::shared_ptr<BtHandshakeMessage> msg;
   if(handshakeSent_ || !quickReply || peerConnection_->getBufferLength() < 48) {
     if(peerConnection_->receiveHandshake(data, dataLength)) {
       msg = messageFactory_->createHandshakeMessage(data, dataLength);
@@ -100,40 +100,39 @@ DefaultBtMessageReceiver::receiveHandshake(bool quickReply)
   return msg;
 }
 
-SharedHandle<BtHandshakeMessage>
+std::shared_ptr<BtHandshakeMessage>
 DefaultBtMessageReceiver::receiveAndSendHandshake()
 {
   return receiveHandshake(true);
 }
 
 void DefaultBtMessageReceiver::sendHandshake() {
-  SharedHandle<BtMessage> msg =
+  std::shared_ptr<BtMessage> msg =
     messageFactory_->createHandshakeMessage
     (bittorrent::getInfoHash(downloadContext_), bittorrent::getStaticPeerId());
   dispatcher_->addMessageToQueue(msg);
   dispatcher_->sendMessages();
 }
 
-SharedHandle<BtMessage> DefaultBtMessageReceiver::receiveMessage() {
+std::shared_ptr<BtMessage> DefaultBtMessageReceiver::receiveMessage() {
   size_t dataLength = 0;
   // Give 0 to PeerConnection::receiveMessage() to prevent memcpy.
   if(!peerConnection_->receiveMessage(0, dataLength)) {
-    return SharedHandle<BtMessage>();
+    return std::shared_ptr<BtMessage>();
   }
-  SharedHandle<BtMessage> msg =
+  std::shared_ptr<BtMessage> msg =
     messageFactory_->createBtMessage(peerConnection_->getMsgPayloadBuffer(),
                                      dataLength);
   msg->validate();
   if(msg->getId() == BtPieceMessage::ID) {
-    SharedHandle<BtPieceMessage> piecemsg =
-      static_pointer_cast<BtPieceMessage>(msg);
+    auto piecemsg = std::static_pointer_cast<BtPieceMessage>(msg);
     piecemsg->setMsgPayload(peerConnection_->getMsgPayloadBuffer());
   }
   return msg;
 }
 
 void DefaultBtMessageReceiver::setDownloadContext
-(const SharedHandle<DownloadContext>& downloadContext)
+(const std::shared_ptr<DownloadContext>& downloadContext)
 {
   downloadContext_ = downloadContext;
 }
diff --git a/src/DefaultBtMessageReceiver.h b/src/DefaultBtMessageReceiver.h
index 05a0b07d..5624545a 100644
--- a/src/DefaultBtMessageReceiver.h
+++ b/src/DefaultBtMessageReceiver.h
@@ -49,7 +49,7 @@ class BtMessageFactory;
 class DefaultBtMessageReceiver : public BtMessageReceiver {
 private:
   bool handshakeSent_;
-  SharedHandle<DownloadContext> downloadContext_;
+  std::shared_ptr<DownloadContext> downloadContext_;
   PeerConnection* peerConnection_;
   BtMessageDispatcher* dispatcher_;
   BtMessageFactory* messageFactory_;
@@ -58,14 +58,14 @@ private:
 public:
   DefaultBtMessageReceiver();
 
-  virtual SharedHandle<BtHandshakeMessage> receiveHandshake
+  virtual std::shared_ptr<BtHandshakeMessage> receiveHandshake
   (bool quickReply = false);
 
-  virtual SharedHandle<BtHandshakeMessage> receiveAndSendHandshake();
+  virtual std::shared_ptr<BtHandshakeMessage> receiveAndSendHandshake();
 
-  virtual SharedHandle<BtMessage> receiveMessage();
+  virtual std::shared_ptr<BtMessage> receiveMessage();
 
-  void setDownloadContext(const SharedHandle<DownloadContext>& downloadContext);
+  void setDownloadContext(const std::shared_ptr<DownloadContext>& downloadContext);
 
   void setPeerConnection(PeerConnection* peerConnection);
 
diff --git a/src/DefaultBtProgressInfoFile.cc b/src/DefaultBtProgressInfoFile.cc
index 44d9939a..5f5c2ca9 100644
--- a/src/DefaultBtProgressInfoFile.cc
+++ b/src/DefaultBtProgressInfoFile.cc
@@ -65,7 +65,7 @@ namespace aria2 {
 
 namespace {
 std::string createFilename
-(const SharedHandle<DownloadContext>& dctx, const std::string& suffix)
+(const std::shared_ptr<DownloadContext>& dctx, const std::string& suffix)
 {
   std::string t = dctx->getBasePath();
   t += suffix;
@@ -74,8 +74,8 @@ std::string createFilename
 } // namespace
 
 DefaultBtProgressInfoFile::DefaultBtProgressInfoFile
-(const SharedHandle<DownloadContext>& dctx,
- const SharedHandle<PieceStorage>& pieceStorage,
+(const std::shared_ptr<DownloadContext>& dctx,
+ const std::shared_ptr<PieceStorage>& pieceStorage,
  const Option* option)
   : dctx_(dctx),
     pieceStorage_(pieceStorage),
@@ -93,7 +93,7 @@ void DefaultBtProgressInfoFile::updateFilename()
 bool DefaultBtProgressInfoFile::isTorrentDownload()
 {
 #ifdef ENABLE_BITTORRENT
-  return btRuntime_;
+  return btRuntime_.get();
 #else // !ENABLE_BITTORRENT
   return false;
 #endif // !ENABLE_BITTORRENT
@@ -174,10 +174,10 @@ void DefaultBtProgressInfoFile::save()
     // TODO implement this
     uint32_t numInFlightPieceNL = htonl(pieceStorage_->countInFlightPiece());
     WRITE_CHECK(fp, &numInFlightPieceNL, sizeof(numInFlightPieceNL));
-    std::vector<SharedHandle<Piece> > inFlightPieces;
+    std::vector<std::shared_ptr<Piece> > inFlightPieces;
     inFlightPieces.reserve(pieceStorage_->countInFlightPiece());
     pieceStorage_->getInFlightPieces(inFlightPieces);
-    for(std::vector<SharedHandle<Piece> >::const_iterator itr =
+    for(std::vector<std::shared_ptr<Piece> >::const_iterator itr =
           inFlightPieces.begin(), eoi = inFlightPieces.end();
         itr != eoi; ++itr) {
       uint32_t indexNL = htonl((*itr)->getIndex());
@@ -313,7 +313,7 @@ void DefaultBtProgressInfoFile::load()
     if(version >= 1) {
       numInFlightPiece = ntohl(numInFlightPiece);
     }
-    std::vector<SharedHandle<Piece> > inFlightPieces;
+    std::vector<std::shared_ptr<Piece> > inFlightPieces;
     inFlightPieces.reserve(numInFlightPiece);
     while(numInFlightPiece--) {
       uint32_t index;
@@ -332,7 +332,7 @@ void DefaultBtProgressInfoFile::load()
       if(!(length <= static_cast<uint32_t>(dctx_->getPieceLength()))) {
         throw DL_ABORT_EX(fmt("piece length out of range: %u", length));
       }
-      SharedHandle<Piece> piece(new Piece(index, length));
+      std::shared_ptr<Piece> piece(new Piece(index, length));
       uint32_t bitfieldLength;
       READ_CHECK(fp, &bitfieldLength, sizeof(bitfieldLength));
       if(version >= 1) {
@@ -405,13 +405,13 @@ bool DefaultBtProgressInfoFile::exists()
 
 #ifdef ENABLE_BITTORRENT
 void DefaultBtProgressInfoFile::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
 
 void DefaultBtProgressInfoFile::setBtRuntime
-(const SharedHandle<BtRuntime>& btRuntime)
+(const std::shared_ptr<BtRuntime>& btRuntime)
 {
   btRuntime_ = btRuntime;
 }
diff --git a/src/DefaultBtProgressInfoFile.h b/src/DefaultBtProgressInfoFile.h
index f81a2fae..5c821d77 100644
--- a/src/DefaultBtProgressInfoFile.h
+++ b/src/DefaultBtProgressInfoFile.h
@@ -36,7 +36,8 @@
 #define D_DEFAULT_BT_PROGRESS_INFO_FILE_H
 
 #include "BtProgressInfoFile.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -48,19 +49,19 @@ class Option;
 
 class DefaultBtProgressInfoFile : public BtProgressInfoFile {
 private:
-  SharedHandle<DownloadContext> dctx_;
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<DownloadContext> dctx_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
 #ifdef ENABLE_BITTORRENT
-  SharedHandle<PeerStorage> peerStorage_;
-  SharedHandle<BtRuntime> btRuntime_;
+  std::shared_ptr<PeerStorage> peerStorage_;
+  std::shared_ptr<BtRuntime> btRuntime_;
 #endif // ENABLE_BITTORRENT
   const Option* option_;
   std::string filename_;
 
   bool isTorrentDownload();
 public:
-  DefaultBtProgressInfoFile(const SharedHandle<DownloadContext>& btContext,
-                            const SharedHandle<PieceStorage>& pieceStorage,
+  DefaultBtProgressInfoFile(const std::shared_ptr<DownloadContext>& btContext,
+                            const std::shared_ptr<PieceStorage>& pieceStorage,
                             const Option* option);
 
   virtual ~DefaultBtProgressInfoFile();
@@ -80,9 +81,9 @@ public:
 
 #ifdef ENABLE_BITTORRENT
   // for torrents
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 
-  void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime);
+  void setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime);
 #endif // ENABLE_BITTORRENT
 
   static const std::string& getSuffix()
diff --git a/src/DefaultBtRequestFactory.cc b/src/DefaultBtRequestFactory.cc
index e10b2e60..449afba7 100644
--- a/src/DefaultBtRequestFactory.cc
+++ b/src/DefaultBtRequestFactory.cc
@@ -59,7 +59,7 @@ DefaultBtRequestFactory::DefaultBtRequestFactory()
 
 DefaultBtRequestFactory::~DefaultBtRequestFactory() {}
 
-void DefaultBtRequestFactory::addTargetPiece(const SharedHandle<Piece>& piece)
+void DefaultBtRequestFactory::addTargetPiece(const std::shared_ptr<Piece>& piece)
 {
   pieces_.push_back(piece);
 }
@@ -73,7 +73,7 @@ public:
   AbortCompletedPieceRequest(BtMessageDispatcher* dispatcher):
     dispatcher_(dispatcher) {}
 
-  void operator()(const SharedHandle<Piece>& piece)
+  void operator()(const std::shared_ptr<Piece>& piece)
   {
     if(piece->pieceComplete()) {
       dispatcher_->doAbortOutstandingRequestAction(piece);
@@ -91,7 +91,7 @@ void DefaultBtRequestFactory::removeCompletedPiece() {
 }
 
 void DefaultBtRequestFactory::removeTargetPiece
-(const SharedHandle<Piece>& piece)
+(const std::shared_ptr<Piece>& piece)
 {
   pieces_.erase(std::remove_if(pieces_.begin(), pieces_.end(),
                                derefEqual(piece)),
@@ -103,19 +103,19 @@ void DefaultBtRequestFactory::removeTargetPiece
 namespace {
 class ProcessChokedPiece {
 private:
-  SharedHandle<Peer> peer_;
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<Peer> peer_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
   cuid_t cuid_;
 public:
-  ProcessChokedPiece(const SharedHandle<Peer>& peer,
-                     const SharedHandle<PieceStorage>& pieceStorage,
+  ProcessChokedPiece(const std::shared_ptr<Peer>& peer,
+                     const std::shared_ptr<PieceStorage>& pieceStorage,
                      cuid_t cuid):
     peer_(peer),
     pieceStorage_(pieceStorage),
     cuid_(cuid)
   {}
 
-  void operator()(const SharedHandle<Piece>& piece)
+  void operator()(const std::shared_ptr<Piece>& piece)
   {
     if(!peer_->isInPeerAllowedIndexSet(piece->getIndex())) {
       pieceStorage_->cancelPiece(piece, cuid_);
@@ -127,11 +127,11 @@ public:
 namespace {
 class FindChokedPiece {
 private:
-  SharedHandle<Peer> peer_;
+  std::shared_ptr<Peer> peer_;
 public:
-  FindChokedPiece(const SharedHandle<Peer>& peer):peer_(peer) {}
+  FindChokedPiece(const std::shared_ptr<Peer>& peer):peer_(peer) {}
 
-  bool operator()(const SharedHandle<Piece>& piece)
+  bool operator()(const std::shared_ptr<Piece>& piece)
   {
     return !peer_->isInPeerAllowedIndexSet(piece->getIndex());
   }
@@ -148,7 +148,7 @@ void DefaultBtRequestFactory::doChokedAction()
 }
 
 void DefaultBtRequestFactory::removeAllTargetPiece() {
-  for(std::deque<SharedHandle<Piece> >::iterator itr = pieces_.begin(),
+  for(std::deque<std::shared_ptr<Piece> >::iterator itr = pieces_.begin(),
         eoi = pieces_.end(); itr != eoi; ++itr) {
     dispatcher_->doAbortOutstandingRequestAction(*itr);
     pieceStorage_->cancelPiece(*itr, cuid_);
@@ -157,7 +157,7 @@ void DefaultBtRequestFactory::removeAllTargetPiece() {
 }
 
 void DefaultBtRequestFactory::createRequestMessages
-(std::vector<SharedHandle<BtMessage> >& requests, size_t max)
+(std::vector<std::shared_ptr<BtMessage> >& requests, size_t max)
 {
   if(requests.size() >= max) {
     return;
@@ -165,9 +165,9 @@ void DefaultBtRequestFactory::createRequestMessages
   size_t getnum = max-requests.size();
   std::vector<size_t> blockIndexes;
   blockIndexes.reserve(getnum);
-  for(std::deque<SharedHandle<Piece> >::iterator itr = pieces_.begin(),
+  for(std::deque<std::shared_ptr<Piece> >::iterator itr = pieces_.begin(),
         eoi = pieces_.end(); itr != eoi && getnum; ++itr) {
-    SharedHandle<Piece>& piece = *itr;
+    std::shared_ptr<Piece>& piece = *itr;
     if(piece->getMissingUnusedBlockIndex(blockIndexes, getnum)) {
       getnum -= blockIndexes.size();
       for(std::vector<size_t>::const_iterator i = blockIndexes.begin(),
@@ -187,11 +187,11 @@ void DefaultBtRequestFactory::createRequestMessages
 }
 
 void DefaultBtRequestFactory::createRequestMessagesOnEndGame
-(std::vector<SharedHandle<BtMessage> >& requests, size_t max)
+(std::vector<std::shared_ptr<BtMessage> >& requests, size_t max)
 {
-  for(std::deque<SharedHandle<Piece> >::iterator itr = pieces_.begin(),
+  for(std::deque<std::shared_ptr<Piece> >::iterator itr = pieces_.begin(),
         eoi = pieces_.end(); itr != eoi && requests.size() < max; ++itr) {
-    SharedHandle<Piece>& piece = *itr;
+    std::shared_ptr<Piece>& piece = *itr;
     const size_t mislen = piece->getBitfieldLength();
     array_ptr<unsigned char> misbitfield(new unsigned char[mislen]);
 
@@ -242,7 +242,7 @@ public:
     return numMissingBlock_;
   }
 
-  void operator()(const SharedHandle<Piece>& piece)
+  void operator()(const std::shared_ptr<Piece>& piece)
   {
     numMissingBlock_ += piece->countMissingBlock();
   }
@@ -263,12 +263,12 @@ void DefaultBtRequestFactory::getTargetPieceIndexes
 }
 
 void DefaultBtRequestFactory::setPieceStorage
-(const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
 
-void DefaultBtRequestFactory::setPeer(const SharedHandle<Peer>& peer)
+void DefaultBtRequestFactory::setPeer(const std::shared_ptr<Peer>& peer)
 {
   peer_ = peer;
 }
diff --git a/src/DefaultBtRequestFactory.h b/src/DefaultBtRequestFactory.h
index 33534085..d845da70 100644
--- a/src/DefaultBtRequestFactory.h
+++ b/src/DefaultBtRequestFactory.h
@@ -51,20 +51,20 @@ class Piece;
 
 class DefaultBtRequestFactory : public BtRequestFactory {
 private:
-  SharedHandle<PieceStorage> pieceStorage_;
-  SharedHandle<Peer> peer_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
+  std::shared_ptr<Peer> peer_;
   BtMessageDispatcher* dispatcher_;
   BtMessageFactory* messageFactory_;
-  std::deque<SharedHandle<Piece> > pieces_;
+  std::deque<std::shared_ptr<Piece> > pieces_;
   cuid_t cuid_;
 public:
   DefaultBtRequestFactory();
 
   virtual ~DefaultBtRequestFactory();
 
-  virtual void addTargetPiece(const SharedHandle<Piece>& piece);
+  virtual void addTargetPiece(const std::shared_ptr<Piece>& piece);
 
-  virtual void removeTargetPiece(const SharedHandle<Piece>& piece);
+  virtual void removeTargetPiece(const std::shared_ptr<Piece>& piece);
 
   virtual void removeAllTargetPiece();
 
@@ -79,21 +79,21 @@ public:
   virtual void doChokedAction();
 
   virtual void createRequestMessages
-  (std::vector<SharedHandle<BtMessage> >& requests, size_t max);
+  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max);
 
   virtual void createRequestMessagesOnEndGame
-  (std::vector<SharedHandle<BtMessage> >& requests, size_t max);
+  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max);
 
   virtual void getTargetPieceIndexes(std::vector<size_t>& indexes) const;
 
-  std::deque<SharedHandle<Piece> >& getTargetPieces()
+  std::deque<std::shared_ptr<Piece> >& getTargetPieces()
   {
     return pieces_;
   }
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 
-  void setPeer(const SharedHandle<Peer>& peer);
+  void setPeer(const std::shared_ptr<Peer>& peer);
 
   void setBtMessageDispatcher(BtMessageDispatcher* dispatcher);
 
diff --git a/src/DefaultDiskWriterFactory.cc b/src/DefaultDiskWriterFactory.cc
index 7107eae8..b2bd9be2 100644
--- a/src/DefaultDiskWriterFactory.cc
+++ b/src/DefaultDiskWriterFactory.cc
@@ -37,10 +37,10 @@
 
 namespace aria2 {
 
-SharedHandle<DiskWriter> DefaultDiskWriterFactory::newDiskWriter
+std::shared_ptr<DiskWriter> DefaultDiskWriterFactory::newDiskWriter
 (const std::string& filename)
 {
-  return SharedHandle<DiskWriter>(new DefaultDiskWriter(filename));
+  return std::shared_ptr<DiskWriter>(new DefaultDiskWriter(filename));
 }
 
 } // namespace aria2
diff --git a/src/DefaultDiskWriterFactory.h b/src/DefaultDiskWriterFactory.h
index b321d7d1..f13f07e9 100644
--- a/src/DefaultDiskWriterFactory.h
+++ b/src/DefaultDiskWriterFactory.h
@@ -44,7 +44,7 @@ class DiskWriter;
 class DefaultDiskWriterFactory:public DiskWriterFactory
 {
 public:
-  virtual SharedHandle<DiskWriter> newDiskWriter(const std::string& filename);
+  virtual std::shared_ptr<DiskWriter> newDiskWriter(const std::string& filename);
 };
 
 } // namespace aria2
diff --git a/src/DefaultExtensionMessageFactory.cc b/src/DefaultExtensionMessageFactory.cc
index fc37a3b9..202b1ca4 100644
--- a/src/DefaultExtensionMessageFactory.cc
+++ b/src/DefaultExtensionMessageFactory.cc
@@ -64,8 +64,8 @@ DefaultExtensionMessageFactory::DefaultExtensionMessageFactory()
 {}
 
 DefaultExtensionMessageFactory::DefaultExtensionMessageFactory
-(const SharedHandle<Peer>& peer,
- const SharedHandle<ExtensionMessageRegistry>& registry)
+(const std::shared_ptr<Peer>& peer,
+ const std::shared_ptr<ExtensionMessageRegistry>& registry)
   : peer_(peer),
     registry_(registry),
     messageFactory_(0),
@@ -75,7 +75,7 @@ DefaultExtensionMessageFactory::DefaultExtensionMessageFactory
 
 DefaultExtensionMessageFactory::~DefaultExtensionMessageFactory() {}
 
-SharedHandle<ExtensionMessage>
+std::shared_ptr<ExtensionMessage>
 DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t length)
 {
   uint8_t extensionMessageID = *data;
@@ -85,7 +85,7 @@ DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t
       HandshakeExtensionMessage::create(data, length);
     m->setPeer(peer_);
     m->setDownloadContext(dctx_);
-    return SharedHandle<ExtensionMessage>(m);
+    return std::shared_ptr<ExtensionMessage>(m);
   } else {
     const char* extensionName = registry_->getExtensionName(extensionMessageID);
     if(!extensionName) {
@@ -97,7 +97,7 @@ DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t
       // uTorrent compatible Peer-Exchange
       UTPexExtensionMessage* m = UTPexExtensionMessage::create(data, length);
       m->setPeerStorage(peerStorage_);
-      return SharedHandle<ExtensionMessage>(m);
+      return std::shared_ptr<ExtensionMessage>(m);
     } else if(strcmp(extensionName, "ut_metadata") == 0) {
       if(length == 0) {
         throw DL_ABORT_EX
@@ -106,7 +106,7 @@ DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t
                static_cast<unsigned long>(length)));
       }
       size_t end;
-      SharedHandle<ValueBase> decoded =
+      std::shared_ptr<ValueBase> decoded =
         bencode2::decode(data+1, length - 1, end);
       const Dict* dict = downcast<Dict>(decoded);
       if(!dict) {
@@ -129,7 +129,7 @@ DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t
         m->setPeer(peer_);
         m->setBtMessageFactory(messageFactory_);
         m->setBtMessageDispatcher(dispatcher_);
-        return SharedHandle<ExtensionMessage>(m);
+        return std::shared_ptr<ExtensionMessage>(m);
       }
       case 1: {
         if(end == length) {
@@ -147,14 +147,14 @@ DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t
         m->setUTMetadataRequestTracker(tracker_);
         m->setPieceStorage(dctx_->getOwnerRequestGroup()->getPieceStorage());
         m->setDownloadContext(dctx_);
-        return SharedHandle<ExtensionMessage>(m);
+        return std::shared_ptr<ExtensionMessage>(m);
       }
       case 2: {
         UTMetadataRejectExtensionMessage* m
           (new UTMetadataRejectExtensionMessage(extensionMessageID));
         m->setIndex(index->i());
         // No need to inject tracker because peer will be disconnected.
-        return SharedHandle<ExtensionMessage>(m);
+        return std::shared_ptr<ExtensionMessage>(m);
       }
       default:
         throw DL_ABORT_EX
@@ -171,12 +171,12 @@ DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t
 }
 
 void DefaultExtensionMessageFactory::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
 
-void DefaultExtensionMessageFactory::setPeer(const SharedHandle<Peer>& peer)
+void DefaultExtensionMessageFactory::setPeer(const std::shared_ptr<Peer>& peer)
 {
   peer_ = peer;
 }
diff --git a/src/DefaultExtensionMessageFactory.h b/src/DefaultExtensionMessageFactory.h
index 908855cb..ab56d33d 100644
--- a/src/DefaultExtensionMessageFactory.h
+++ b/src/DefaultExtensionMessageFactory.h
@@ -49,13 +49,13 @@ class UTMetadataRequestTracker;
 
 class DefaultExtensionMessageFactory:public ExtensionMessageFactory {
 private:
-  SharedHandle<PeerStorage> peerStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
 
-  SharedHandle<Peer> peer_;
+  std::shared_ptr<Peer> peer_;
 
-  SharedHandle<ExtensionMessageRegistry> registry_;
+  std::shared_ptr<ExtensionMessageRegistry> registry_;
 
-  SharedHandle<DownloadContext> dctx_;
+  std::shared_ptr<DownloadContext> dctx_;
 
   BtMessageFactory* messageFactory_;
 
@@ -66,25 +66,25 @@ public:
   DefaultExtensionMessageFactory();
 
   DefaultExtensionMessageFactory
-  (const SharedHandle<Peer>& peer,
-   const SharedHandle<ExtensionMessageRegistry>& registry);
+  (const std::shared_ptr<Peer>& peer,
+   const std::shared_ptr<ExtensionMessageRegistry>& registry);
 
   virtual ~DefaultExtensionMessageFactory();
 
-  virtual SharedHandle<ExtensionMessage>
+  virtual std::shared_ptr<ExtensionMessage>
   createMessage(const unsigned char* data, size_t length);
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 
-  void setPeer(const SharedHandle<Peer>& peer);
+  void setPeer(const std::shared_ptr<Peer>& peer);
 
   void setExtensionMessageRegistry
-  (const SharedHandle<ExtensionMessageRegistry>& registry)
+  (const std::shared_ptr<ExtensionMessageRegistry>& registry)
   {
     registry_ = registry;
   }
 
-  void setDownloadContext(const SharedHandle<DownloadContext>& dctx)
+  void setDownloadContext(const std::shared_ptr<DownloadContext>& dctx)
   {
     dctx_ = dctx;
   }
diff --git a/src/DefaultPeerStorage.cc b/src/DefaultPeerStorage.cc
index 235f2c5d..473522de 100644
--- a/src/DefaultPeerStorage.cc
+++ b/src/DefaultPeerStorage.cc
@@ -77,18 +77,18 @@ size_t DefaultPeerStorage::countAllPeer() const
   return unusedPeers_.size() + usedPeers_.size();
 }
 
-bool DefaultPeerStorage::isPeerAlreadyAdded(const SharedHandle<Peer>& peer)
+bool DefaultPeerStorage::isPeerAlreadyAdded(const std::shared_ptr<Peer>& peer)
 {
   return uniqPeers_.count(std::make_pair(peer->getIPAddress(),
                                          peer->getOrigPort()));
 }
 
-void DefaultPeerStorage::addUniqPeer(const SharedHandle<Peer>& peer)
+void DefaultPeerStorage::addUniqPeer(const std::shared_ptr<Peer>& peer)
 {
   uniqPeers_.insert(std::make_pair(peer->getIPAddress(), peer->getOrigPort()));
 }
 
-bool DefaultPeerStorage::addPeer(const SharedHandle<Peer>& peer)
+bool DefaultPeerStorage::addPeer(const std::shared_ptr<Peer>& peer)
 {
   if(isPeerAlreadyAdded(peer)) {
     A2_LOG_DEBUG(fmt("Adding %s:%u is rejected because it has been already"
@@ -112,13 +112,13 @@ bool DefaultPeerStorage::addPeer(const SharedHandle<Peer>& peer)
   return true;
 }
 
-void DefaultPeerStorage::addPeer(const std::vector<SharedHandle<Peer> >& peers)
+void DefaultPeerStorage::addPeer(const std::vector<std::shared_ptr<Peer> >& peers)
 {
   size_t added = 0;
   size_t addMax = std::min(maxPeerListSize_, MAX_PEER_LIST_UPDATE);
-  for(std::vector<SharedHandle<Peer> >::const_iterator itr = peers.begin(),
+  for(std::vector<std::shared_ptr<Peer> >::const_iterator itr = peers.begin(),
         eoi = peers.end(); itr != eoi && added < addMax; ++itr) {
-    const SharedHandle<Peer>& peer = *itr;
+    const std::shared_ptr<Peer>& peer = *itr;
     if(isPeerAlreadyAdded(peer)) {
       A2_LOG_DEBUG(fmt("Adding %s:%u is rejected because it has been already"
                        " added.",
@@ -144,11 +144,11 @@ void DefaultPeerStorage::addPeer(const std::vector<SharedHandle<Peer> >& peers)
                    static_cast<unsigned long>(unusedPeers_.size())));
 }
 
-void DefaultPeerStorage::addDroppedPeer(const SharedHandle<Peer>& peer)
+void DefaultPeerStorage::addDroppedPeer(const std::shared_ptr<Peer>& peer)
 {
   // Make sure that duplicated peers exist in droppedPeers_. If
   // exists, erase older one.
-  for(std::deque<SharedHandle<Peer> >::iterator i = droppedPeers_.begin(),
+  for(std::deque<std::shared_ptr<Peer> >::iterator i = droppedPeers_.begin(),
         eoi = droppedPeers_.end(); i != eoi; ++i) {
     if((*i)->getIPAddress() == peer->getIPAddress() &&
        (*i)->getPort() == peer->getPort()) {
@@ -162,7 +162,7 @@ void DefaultPeerStorage::addDroppedPeer(const SharedHandle<Peer>& peer)
   }
 }
 
-const std::deque<SharedHandle<Peer> >& DefaultPeerStorage::getUnusedPeers()
+const std::deque<std::shared_ptr<Peer> >& DefaultPeerStorage::getUnusedPeers()
 {
   return unusedPeers_;
 }
@@ -172,7 +172,7 @@ const PeerSet& DefaultPeerStorage::getUsedPeers()
   return usedPeers_;
 }
 
-const std::deque<SharedHandle<Peer> >& DefaultPeerStorage::getDroppedPeers()
+const std::deque<std::shared_ptr<Peer> >& DefaultPeerStorage::getDroppedPeers()
 {
   return droppedPeers_;
 }
@@ -222,28 +222,28 @@ void DefaultPeerStorage::deleteUnusedPeer(size_t delSize) {
   }
 }
 
-SharedHandle<Peer> DefaultPeerStorage::checkoutPeer(cuid_t cuid)
+std::shared_ptr<Peer> DefaultPeerStorage::checkoutPeer(cuid_t cuid)
 {
   if(!isPeerAvailable()) {
-    return SharedHandle<Peer>();
+    return std::shared_ptr<Peer>();
   }
-  SharedHandle<Peer> peer = unusedPeers_.front();
+  std::shared_ptr<Peer> peer = unusedPeers_.front();
   unusedPeers_.pop_front();
   peer->usedBy(cuid);
   usedPeers_.insert(peer);
-  A2_LOG_DEBUG(fmt("Checkout peer %s:%u to CUID#%"PRId64,
+  A2_LOG_DEBUG(fmt("Checkout peer %s:%u to CUID#%" PRId64,
                    peer->getIPAddress().c_str(), peer->getPort(),
                    peer->usedBy()));
   return peer;
 }
 
-void DefaultPeerStorage::onErasingPeer(const SharedHandle<Peer>& peer)
+void DefaultPeerStorage::onErasingPeer(const std::shared_ptr<Peer>& peer)
 {
   uniqPeers_.erase(std::make_pair(peer->getIPAddress(),
                                   peer->getOrigPort()));
 }
 
-void DefaultPeerStorage::onReturningPeer(const SharedHandle<Peer>& peer)
+void DefaultPeerStorage::onReturningPeer(const std::shared_ptr<Peer>& peer)
 {
   if(peer->isActive()) {
     if(peer->isDisconnectedGracefully() && !peer->isIncomingPeer()) {
@@ -259,9 +259,9 @@ void DefaultPeerStorage::onReturningPeer(const SharedHandle<Peer>& peer)
   peer->usedBy(0);
 }
 
-void DefaultPeerStorage::returnPeer(const SharedHandle<Peer>& peer)
+void DefaultPeerStorage::returnPeer(const std::shared_ptr<Peer>& peer)
 {
-  A2_LOG_DEBUG(fmt("Peer %s:%u returned from CUID#%"PRId64,
+  A2_LOG_DEBUG(fmt("Peer %s:%u returned from CUID#%" PRId64,
                    peer->getIPAddress().c_str(), peer->getPort(),
                    peer->usedBy()));
   if(usedPeers_.erase(peer)) {
@@ -294,12 +294,12 @@ void DefaultPeerStorage::executeChoke()
   }
 }
 
-void DefaultPeerStorage::setPieceStorage(const SharedHandle<PieceStorage>& ps)
+void DefaultPeerStorage::setPieceStorage(const std::shared_ptr<PieceStorage>& ps)
 {
   pieceStorage_ = ps;
 }
 
-void DefaultPeerStorage::setBtRuntime(const SharedHandle<BtRuntime>& btRuntime)
+void DefaultPeerStorage::setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime)
 {
   btRuntime_ = btRuntime;
 }
diff --git a/src/DefaultPeerStorage.h b/src/DefaultPeerStorage.h
index 77e9b00d..3e43d798 100644
--- a/src/DefaultPeerStorage.h
+++ b/src/DefaultPeerStorage.h
@@ -51,20 +51,20 @@ class PieceStorage;
 
 class DefaultPeerStorage : public PeerStorage {
 private:
-  SharedHandle<BtRuntime> btRuntime_;
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<BtRuntime> btRuntime_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
   size_t maxPeerListSize_;
 
   // This contains ip address and port pair and is used to ensure that
   // no duplicate peers are stored.
   std::set<std::pair<std::string, uint16_t> > uniqPeers_;
   // Unused (not connected) peers, sorted by last added.
-  std::deque<SharedHandle<Peer> > unusedPeers_;
+  std::deque<std::shared_ptr<Peer> > unusedPeers_;
   // The set of used peers. Some of them are not connected yet. To
   // know it is connected or not, call Peer::isActive().
   PeerSet usedPeers_;
 
-  std::deque<SharedHandle<Peer> > droppedPeers_;
+  std::deque<std::shared_ptr<Peer> > droppedPeers_;
 
   BtSeederStateChoke* seederStateChoke_;
   BtLeecherStateChoke* leecherStateChoke_;
@@ -74,29 +74,29 @@ private:
   std::map<std::string, time_t> badPeers_;
   Timer lastBadPeerCleaned_;
 
-  bool isPeerAlreadyAdded(const SharedHandle<Peer>& peer);
-  void addUniqPeer(const SharedHandle<Peer>& peer);
+  bool isPeerAlreadyAdded(const std::shared_ptr<Peer>& peer);
+  void addUniqPeer(const std::shared_ptr<Peer>& peer);
 
-  void addDroppedPeer(const SharedHandle<Peer>& peer);
+  void addDroppedPeer(const std::shared_ptr<Peer>& peer);
 public:
   DefaultPeerStorage();
 
   virtual ~DefaultPeerStorage();
 
   // TODO We need addAndCheckoutPeer for incoming peers
-  virtual bool addPeer(const SharedHandle<Peer>& peer);
+  virtual bool addPeer(const std::shared_ptr<Peer>& peer);
 
   virtual size_t countAllPeer() const;
 
-  SharedHandle<Peer> getPeer(const std::string& ipaddr, uint16_t port) const;
+  std::shared_ptr<Peer> getPeer(const std::string& ipaddr, uint16_t port) const;
 
-  virtual void addPeer(const std::vector<SharedHandle<Peer> >& peers);
+  virtual void addPeer(const std::vector<std::shared_ptr<Peer> >& peers);
 
-  const std::deque<SharedHandle<Peer> >& getUnusedPeers();
+  const std::deque<std::shared_ptr<Peer> >& getUnusedPeers();
 
   virtual const PeerSet& getUsedPeers();
 
-  virtual const std::deque<SharedHandle<Peer> >& getDroppedPeers();
+  virtual const std::deque<std::shared_ptr<Peer> >& getDroppedPeers();
 
   virtual bool isPeerAvailable();
 
@@ -104,9 +104,9 @@ public:
 
   virtual void addBadPeer(const std::string& ipaddr);
 
-  virtual SharedHandle<Peer> checkoutPeer(cuid_t cuid);
+  virtual std::shared_ptr<Peer> checkoutPeer(cuid_t cuid);
 
-  virtual void returnPeer(const SharedHandle<Peer>& peer);
+  virtual void returnPeer(const std::shared_ptr<Peer>& peer);
 
   virtual bool chokeRoundIntervalElapsed();
 
@@ -114,13 +114,13 @@ public:
 
   void deleteUnusedPeer(size_t delSize);
 
-  void onErasingPeer(const SharedHandle<Peer>& peer);
+  void onErasingPeer(const std::shared_ptr<Peer>& peer);
 
-  void onReturningPeer(const SharedHandle<Peer>& peer);
+  void onReturningPeer(const std::shared_ptr<Peer>& peer);
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 
-  void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime);
+  void setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime);
 
   void setMaxPeerListSize(size_t maxPeerListSize)
   {
diff --git a/src/DefaultPieceStorage.cc b/src/DefaultPieceStorage.cc
index 46012a90..cef39f04 100644
--- a/src/DefaultPieceStorage.cc
+++ b/src/DefaultPieceStorage.cc
@@ -74,7 +74,7 @@
 namespace aria2 {
 
 DefaultPieceStorage::DefaultPieceStorage
-(const SharedHandle<DownloadContext>& downloadContext, const Option* option)
+(const std::shared_ptr<DownloadContext>& downloadContext, const Option* option)
  : downloadContext_(downloadContext),
    bitfieldMan_(new BitfieldMan(downloadContext->getPieceLength(),
                                 downloadContext->getTotalLength())),
@@ -102,12 +102,12 @@ DefaultPieceStorage::~DefaultPieceStorage()
   delete bitfieldMan_;
 }
 
-SharedHandle<Piece> DefaultPieceStorage::checkOutPiece
+std::shared_ptr<Piece> DefaultPieceStorage::checkOutPiece
 (size_t index, cuid_t cuid)
 {
   bitfieldMan_->setUseBit(index);
 
-  SharedHandle<Piece> piece = findUsedPiece(index);
+  std::shared_ptr<Piece> piece = findUsedPiece(index);
   if(!piece) {
     piece.reset(new Piece(index, bitfieldMan_->getBlockLength(index)));
 #ifdef ENABLE_MESSAGE_DIGEST
@@ -133,9 +133,9 @@ SharedHandle<Piece> DefaultPieceStorage::checkOutPiece
  * Newly instantiated piece is not added to usedPieces.
  * Because it is waste of memory and there is no chance to use them later.
  */
-SharedHandle<Piece> DefaultPieceStorage::getPiece(size_t index)
+std::shared_ptr<Piece> DefaultPieceStorage::getPiece(size_t index)
 {
-  SharedHandle<Piece> piece;
+  std::shared_ptr<Piece> piece;
   if(index <= bitfieldMan_->getMaxIndex()) {
     piece = findUsedPiece(index);
     if(!piece) {
@@ -148,16 +148,16 @@ SharedHandle<Piece> DefaultPieceStorage::getPiece(size_t index)
   return piece;
 }
 
-void DefaultPieceStorage::addUsedPiece(const SharedHandle<Piece>& piece)
+void DefaultPieceStorage::addUsedPiece(const std::shared_ptr<Piece>& piece)
 {
   usedPieces_.insert(piece);
   A2_LOG_DEBUG(fmt("usedPieces_.size()=%lu",
                    static_cast<unsigned long>(usedPieces_.size())));
 }
 
-SharedHandle<Piece> DefaultPieceStorage::findUsedPiece(size_t index) const
+std::shared_ptr<Piece> DefaultPieceStorage::findUsedPiece(size_t index) const
 {
-  SharedHandle<Piece> p(new Piece());
+  std::shared_ptr<Piece> p(new Piece());
   p->setIndex(index);
 
   UsedPieceSet::iterator i = usedPieces_.find(p);
@@ -171,14 +171,14 @@ SharedHandle<Piece> DefaultPieceStorage::findUsedPiece(size_t index) const
 
 #ifdef ENABLE_BITTORRENT
 
-bool DefaultPieceStorage::hasMissingPiece(const SharedHandle<Peer>& peer)
+bool DefaultPieceStorage::hasMissingPiece(const std::shared_ptr<Peer>& peer)
 {
   return bitfieldMan_->hasMissingPiece(peer->getBitfield(),
                                        peer->getBitfieldLength());
 }
 
 void DefaultPieceStorage::getMissingPiece
-(std::vector<SharedHandle<Piece> >& pieces,
+(std::vector<std::shared_ptr<Piece> >& pieces,
  size_t minMissingBlocks,
  const unsigned char* bitfield,
  size_t length,
@@ -203,7 +203,7 @@ void DefaultPieceStorage::getMissingPiece
     std::random_shuffle(indexes.begin(), indexes.end());
     for(std::vector<size_t>::const_iterator i = indexes.begin(),
           eoi = indexes.end(); i != eoi && misBlock < minMissingBlocks; ++i) {
-      SharedHandle<Piece> piece = checkOutPiece(*i, cuid);
+      std::shared_ptr<Piece> piece = checkOutPiece(*i, cuid);
       if(piece->getUsedBySegment()) {
         // We don't share piece downloaded via HTTP/FTP
         piece->removeUser(cuid);
@@ -241,7 +241,7 @@ void unsetExcludedIndexes(BitfieldMan& bitfield,
 } // namespace
 
 void DefaultPieceStorage::createFastIndexBitfield
-(BitfieldMan& bitfield, const SharedHandle<Peer>& peer)
+(BitfieldMan& bitfield, const std::shared_ptr<Peer>& peer)
 {
   for(std::set<size_t>::const_iterator itr =
         peer->getPeerAllowedIndexSet().begin(),
@@ -253,9 +253,9 @@ void DefaultPieceStorage::createFastIndexBitfield
 }
 
 void DefaultPieceStorage::getMissingPiece
-(std::vector<SharedHandle<Piece> >& pieces,
+(std::vector<std::shared_ptr<Piece> >& pieces,
  size_t minMissingBlocks,
- const SharedHandle<Peer>& peer,
+ const std::shared_ptr<Peer>& peer,
  cuid_t cuid)
 {
   getMissingPiece(pieces, minMissingBlocks,
@@ -265,9 +265,9 @@ void DefaultPieceStorage::getMissingPiece
 
 
 void DefaultPieceStorage::getMissingPiece
-(std::vector<SharedHandle<Piece> >& pieces,
+(std::vector<std::shared_ptr<Piece> >& pieces,
  size_t minMissingBlocks,
- const SharedHandle<Peer>& peer,
+ const std::shared_ptr<Peer>& peer,
  const std::vector<size_t>& excludedIndexes,
  cuid_t cuid)
 {
@@ -281,9 +281,9 @@ void DefaultPieceStorage::getMissingPiece
 }
 
 void DefaultPieceStorage::getMissingFastPiece
-(std::vector<SharedHandle<Piece> >& pieces,
+(std::vector<std::shared_ptr<Piece> >& pieces,
  size_t minMissingBlocks,
- const SharedHandle<Peer>& peer,
+ const std::shared_ptr<Peer>& peer,
  cuid_t cuid)
 {
   if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) {
@@ -298,9 +298,9 @@ void DefaultPieceStorage::getMissingFastPiece
 }
 
 void DefaultPieceStorage::getMissingFastPiece
-(std::vector<SharedHandle<Piece> >& pieces,
+(std::vector<std::shared_ptr<Piece> >& pieces,
  size_t minMissingBlocks,
- const SharedHandle<Peer>& peer,
+ const std::shared_ptr<Peer>& peer,
  const std::vector<size_t>& excludedIndexes,
  cuid_t cuid)
 {
@@ -316,56 +316,56 @@ void DefaultPieceStorage::getMissingFastPiece
   }
 }
 
-SharedHandle<Piece>
+std::shared_ptr<Piece>
 DefaultPieceStorage::getMissingPiece
-(const SharedHandle<Peer>& peer,
+(const std::shared_ptr<Peer>& peer,
  cuid_t cuid)
 {
-  std::vector<SharedHandle<Piece> > pieces;
+  std::vector<std::shared_ptr<Piece> > pieces;
   getMissingPiece(pieces, 1, peer, cuid);
   if(pieces.empty()) {
-    return SharedHandle<Piece>();
+    return std::shared_ptr<Piece>();
   } else {
     return pieces.front();
   }
 }
 
-SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
-(const SharedHandle<Peer>& peer,
+std::shared_ptr<Piece> DefaultPieceStorage::getMissingPiece
+(const std::shared_ptr<Peer>& peer,
  const std::vector<size_t>& excludedIndexes,
  cuid_t cuid)
 {
-  std::vector<SharedHandle<Piece> > pieces;
+  std::vector<std::shared_ptr<Piece> > pieces;
   getMissingPiece(pieces, 1, peer, excludedIndexes, cuid);
   if(pieces.empty()) {
-    return SharedHandle<Piece>();
+    return std::shared_ptr<Piece>();
   } else {
     return pieces.front();
   }
 }
 
-SharedHandle<Piece> DefaultPieceStorage::getMissingFastPiece
-(const SharedHandle<Peer>& peer,
+std::shared_ptr<Piece> DefaultPieceStorage::getMissingFastPiece
+(const std::shared_ptr<Peer>& peer,
  cuid_t cuid)
 {
-  std::vector<SharedHandle<Piece> > pieces;
+  std::vector<std::shared_ptr<Piece> > pieces;
   getMissingFastPiece(pieces, 1, peer, cuid);
   if(pieces.empty()) {
-    return SharedHandle<Piece>();
+    return std::shared_ptr<Piece>();
   } else {
     return pieces.front();
   }
 }
 
-SharedHandle<Piece> DefaultPieceStorage::getMissingFastPiece
-(const SharedHandle<Peer>& peer,
+std::shared_ptr<Piece> DefaultPieceStorage::getMissingFastPiece
+(const std::shared_ptr<Peer>& peer,
  const std::vector<size_t>& excludedIndexes,
  cuid_t cuid)
 {
-  std::vector<SharedHandle<Piece> > pieces;
+  std::vector<std::shared_ptr<Piece> > pieces;
   getMissingFastPiece(pieces, 1, peer, excludedIndexes, cuid);
   if(pieces.empty()) {
-    return SharedHandle<Piece>();
+    return std::shared_ptr<Piece>();
   } else {
     return pieces.front();
   }
@@ -379,7 +379,7 @@ bool DefaultPieceStorage::hasMissingUnusedPiece()
   return bitfieldMan_->getFirstMissingUnusedIndex(index);
 }
 
-SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
+std::shared_ptr<Piece> DefaultPieceStorage::getMissingPiece
 (size_t minSplitSize,
  const unsigned char* ignoreBitfield,
  size_t length,
@@ -390,22 +390,22 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
      (index, minSplitSize, ignoreBitfield, length)) {
     return checkOutPiece(index, cuid);
   } else {
-    return SharedHandle<Piece>();
+    return std::shared_ptr<Piece>();
   }
 }
 
-SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
+std::shared_ptr<Piece> DefaultPieceStorage::getMissingPiece
 (size_t index,
  cuid_t cuid)
 {
   if(hasPiece(index) || isPieceUsed(index)) {
-    return SharedHandle<Piece>();
+    return std::shared_ptr<Piece>();
   } else {
     return checkOutPiece(index, cuid);
   }
 }
 
-void DefaultPieceStorage::deleteUsedPiece(const SharedHandle<Piece>& piece)
+void DefaultPieceStorage::deleteUsedPiece(const std::shared_ptr<Piece>& piece)
 {
   if(!piece) {
     return;
@@ -434,7 +434,7 @@ void DefaultPieceStorage::deleteUsedPiece(const SharedHandle<Piece>& piece)
 //   size_t deleted = 0;
 //   for(Pieces::iterator itr = usedPieces.begin();
 //       itr != usedPieces.end() && deleted < delNum;) {
-//     SharedHandle<Piece>& piece = *itr;
+//     std::shared_ptr<Piece>& piece = *itr;
 //     if(!bitfieldMan->isUseBitSet(piece->getIndex()) &&
 //        piece->countCompleteBlock() <= piece->countBlock()*(fillRate/100.0)) {
 //       logger->info(MSG_DELETING_USED_PIECE,
@@ -450,7 +450,7 @@ void DefaultPieceStorage::deleteUsedPiece(const SharedHandle<Piece>& piece)
 //   return deleted;
 // }
 
-void DefaultPieceStorage::completePiece(const SharedHandle<Piece>& piece)
+void DefaultPieceStorage::completePiece(const std::shared_ptr<Piece>& piece)
 {
   if(!piece) {
     return;
@@ -477,7 +477,7 @@ void DefaultPieceStorage::completePiece(const SharedHandle<Piece>& piece)
     }
 #ifdef ENABLE_BITTORRENT
     if(downloadContext_->hasAttribute(CTX_ATTR_BT)) {
-      SharedHandle<TorrentAttribute> torrentAttrs =
+      std::shared_ptr<TorrentAttribute> torrentAttrs =
         bittorrent::getTorrentAttrs(downloadContext_);
       if(!torrentAttrs->metadata.empty()) {
 #ifdef __MINGW32__
@@ -509,7 +509,7 @@ bool DefaultPieceStorage::isSelectiveDownloadingMode()
 
 // not unittested
 void DefaultPieceStorage::cancelPiece
-(const SharedHandle<Piece>& piece, cuid_t cuid)
+(const std::shared_ptr<Piece>& piece, cuid_t cuid)
 {
   if(!piece) {
     return;
@@ -587,10 +587,10 @@ int64_t DefaultPieceStorage::getInFlightPieceFilteredCompletedLength() const
 // not unittested
 void DefaultPieceStorage::setupFileFilter()
 {
-  const std::vector<SharedHandle<FileEntry> >& fileEntries =
+  const std::vector<std::shared_ptr<FileEntry> >& fileEntries =
     downloadContext_->getFileEntries();
   bool allSelected = true;
-  for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
+  for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i =
         fileEntries.begin(), eoi = fileEntries.end();
       i != eoi; ++i) {
     if(!(*i)->isRequested()) {
@@ -601,7 +601,7 @@ void DefaultPieceStorage::setupFileFilter()
   if(allSelected) {
     return;
   }
-  for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
+  for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i =
         fileEntries.begin(), eoi = fileEntries.end(); i != eoi; ++i) {
     if((*i)->isRequested()) {
       bitfieldMan_->addFilter((*i)->getOffset(), (*i)->getLength());
@@ -641,7 +641,7 @@ void DefaultPieceStorage::initStorage()
       (downloadContext_->getFileEntries().begin(),
        downloadContext_->getFileEntries().end());
 
-    SharedHandle<DiskWriter> writer =
+    std::shared_ptr<DiskWriter> writer =
       diskWriterFactory_->newDiskWriter(directDiskAdaptor->getFilePath());
     directDiskAdaptor->setDiskWriter(writer);
     diskAdaptor_.reset(directDiskAdaptor);
@@ -679,7 +679,7 @@ const unsigned char* DefaultPieceStorage::getBitfield()
   return bitfieldMan_->getBitfield();
 }
 
-SharedHandle<DiskAdaptor> DefaultPieceStorage::getDiskAdaptor() {
+std::shared_ptr<DiskAdaptor> DefaultPieceStorage::getDiskAdaptor() {
   return diskAdaptor_;
 }
 
@@ -781,7 +781,7 @@ void DefaultPieceStorage::markPiecesDone(int64_t length)
     }
     size_t r = (length%bitfieldMan_->getBlockLength())/Piece::BLOCK_LENGTH;
     if(r > 0) {
-      SharedHandle<Piece> p
+      std::shared_ptr<Piece> p
         (new Piece(numPiece, bitfieldMan_->getBlockLength(numPiece)));
 
       for(size_t i = 0; i < r; ++i) {
@@ -805,7 +805,7 @@ void DefaultPieceStorage::markPieceMissing(size_t index)
 }
 
 void DefaultPieceStorage::addInFlightPiece
-(const std::vector<SharedHandle<Piece> >& pieces)
+(const std::vector<std::shared_ptr<Piece> >& pieces)
 {
   usedPieces_.insert(pieces.begin(), pieces.end());
 }
@@ -816,13 +816,13 @@ size_t DefaultPieceStorage::countInFlightPiece()
 }
 
 void DefaultPieceStorage::getInFlightPieces
-(std::vector<SharedHandle<Piece> >& pieces)
+(std::vector<std::shared_ptr<Piece> >& pieces)
 {
   pieces.insert(pieces.end(), usedPieces_.begin(), usedPieces_.end());
 }
 
 void DefaultPieceStorage::setDiskWriterFactory
-(const SharedHandle<DiskWriterFactory>& diskWriterFactory)
+(const std::shared_ptr<DiskWriterFactory>& diskWriterFactory)
 {
   diskWriterFactory_ = diskWriterFactory;
 }
diff --git a/src/DefaultPieceStorage.h b/src/DefaultPieceStorage.h
index 328d0876..b0d6e316 100644
--- a/src/DefaultPieceStorage.h
+++ b/src/DefaultPieceStorage.h
@@ -75,12 +75,12 @@ public:
 
 class DefaultPieceStorage : public PieceStorage {
 private:
-  SharedHandle<DownloadContext> downloadContext_;
+  std::shared_ptr<DownloadContext> downloadContext_;
   BitfieldMan* bitfieldMan_;
-  SharedHandle<DiskAdaptor> diskAdaptor_;
-  SharedHandle<DiskWriterFactory> diskWriterFactory_;
-  typedef std::set<SharedHandle<Piece>,
-                   DerefLess<SharedHandle<Piece> > > UsedPieceSet;
+  std::shared_ptr<DiskAdaptor> diskAdaptor_;
+  std::shared_ptr<DiskWriterFactory> diskWriterFactory_;
+  typedef std::set<std::shared_ptr<Piece>,
+                   DerefLess<std::shared_ptr<Piece> > > UsedPieceSet;
   UsedPieceSet usedPieces_;
 
   bool endGame_;
@@ -88,29 +88,29 @@ private:
   const Option* option_;
   std::deque<HaveEntry> haves_;
 
-  SharedHandle<PieceStatMan> pieceStatMan_;
+  std::shared_ptr<PieceStatMan> pieceStatMan_;
 
-  SharedHandle<PieceSelector> pieceSelector_;
-  SharedHandle<StreamPieceSelector> streamPieceSelector_;
+  std::shared_ptr<PieceSelector> pieceSelector_;
+  std::shared_ptr<StreamPieceSelector> streamPieceSelector_;
 
   WrDiskCache* wrDiskCache_;
 #ifdef ENABLE_BITTORRENT
   void getMissingPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
    const unsigned char* bitfield,
    size_t length,
    cuid_t cuid);
 
   void createFastIndexBitfield(BitfieldMan& bitfield,
-                               const SharedHandle<Peer>& peer);
+                               const std::shared_ptr<Peer>& peer);
 #endif // ENABLE_BITTORRENT
 
-  SharedHandle<Piece> checkOutPiece(size_t index, cuid_t cuid);
+  std::shared_ptr<Piece> checkOutPiece(size_t index, cuid_t cuid);
   //   size_t deleteUsedPiecesByFillRate(int fillRate, size_t toDelete);
   //   void reduceUsedPieces(size_t upperBound);
-  void deleteUsedPiece(const SharedHandle<Piece>& piece);
-  SharedHandle<Piece> findUsedPiece(size_t index) const;
+  void deleteUsedPiece(const std::shared_ptr<Piece>& piece);
+  std::shared_ptr<Piece> findUsedPiece(size_t index) const;
 
   // Returns the sum of completed length of in-flight pieces
   int64_t getInFlightPieceCompletedLength() const;
@@ -122,56 +122,56 @@ public:
   // random when more than 2 pieces has the same rarity.
   // If it is set to false, a piece whose index is smallest has the highest
   // priority.
-  DefaultPieceStorage(const SharedHandle<DownloadContext>& downloadContext,
+  DefaultPieceStorage(const std::shared_ptr<DownloadContext>& downloadContext,
                       const Option* option);
 
   virtual ~DefaultPieceStorage();
 
 #ifdef ENABLE_BITTORRENT
 
-  virtual bool hasMissingPiece(const SharedHandle<Peer>& peer);
+  virtual bool hasMissingPiece(const std::shared_ptr<Peer>& peer);
 
   virtual void getMissingPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    cuid_t cuid);
 
   virtual void getMissingPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
    cuid_t cuid);
 
   virtual void getMissingFastPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    cuid_t cuid);
 
   virtual void getMissingFastPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
    cuid_t cuid);
 
-  virtual SharedHandle<Piece> getMissingPiece
-  (const SharedHandle<Peer>& peer,
+  virtual std::shared_ptr<Piece> getMissingPiece
+  (const std::shared_ptr<Peer>& peer,
    cuid_t cuid);
 
-  virtual  SharedHandle<Piece> getMissingPiece
-  (const SharedHandle<Peer>& peer,
+  virtual  std::shared_ptr<Piece> getMissingPiece
+  (const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
    cuid_t cuid);
 
-  SharedHandle<Piece> getMissingFastPiece
-  (const SharedHandle<Peer>& peer,
+  std::shared_ptr<Piece> getMissingFastPiece
+  (const std::shared_ptr<Peer>& peer,
    cuid_t cuid);
 
-  SharedHandle<Piece> getMissingFastPiece
-  (const SharedHandle<Peer>& peer,
+  std::shared_ptr<Piece> getMissingFastPiece
+  (const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
    cuid_t cuid);
 
@@ -179,19 +179,19 @@ public:
 
   virtual bool hasMissingUnusedPiece();
 
-  virtual SharedHandle<Piece> getMissingPiece
+  virtual std::shared_ptr<Piece> getMissingPiece
   (size_t minSplitSize,
    const unsigned char* ignoreBitfield,
    size_t length,
    cuid_t cuid);
 
-  virtual SharedHandle<Piece> getMissingPiece(size_t index, cuid_t cuid);
+  virtual std::shared_ptr<Piece> getMissingPiece(size_t index, cuid_t cuid);
 
-  virtual SharedHandle<Piece> getPiece(size_t index);
+  virtual std::shared_ptr<Piece> getPiece(size_t index);
 
-  virtual void completePiece(const SharedHandle<Piece>& piece);
+  virtual void completePiece(const std::shared_ptr<Piece>& piece);
 
-  virtual void cancelPiece(const SharedHandle<Piece>& piece, cuid_t cuid);
+  virtual void cancelPiece(const std::shared_ptr<Piece>& piece, cuid_t cuid);
 
   virtual bool hasPiece(size_t index);
 
@@ -242,7 +242,7 @@ public:
     endGame_ = true;
   }
 
-  virtual SharedHandle<DiskAdaptor> getDiskAdaptor();
+  virtual std::shared_ptr<DiskAdaptor> getDiskAdaptor();
 
   virtual WrDiskCache* getWrDiskCache();
 
@@ -265,12 +265,12 @@ public:
   virtual void markPieceMissing(size_t index);
 
   virtual void addInFlightPiece
-  (const std::vector<SharedHandle<Piece> >& pieces);
+  (const std::vector<std::shared_ptr<Piece> >& pieces);
 
   virtual size_t countInFlightPiece();
 
   virtual void getInFlightPieces
-  (std::vector<SharedHandle<Piece> >& pieces);
+  (std::vector<std::shared_ptr<Piece> >& pieces);
 
   virtual void addPieceStats(size_t index);
 
@@ -291,22 +291,22 @@ public:
   /**
    * This method is made private for test purpose only.
    */
-  void addUsedPiece(const SharedHandle<Piece>& piece);
+  void addUsedPiece(const std::shared_ptr<Piece>& piece);
 
   void setDiskWriterFactory
-  (const SharedHandle<DiskWriterFactory>& diskWriterFactory);
+  (const std::shared_ptr<DiskWriterFactory>& diskWriterFactory);
 
-  const SharedHandle<PieceStatMan>& getPieceStatMan() const
+  const std::shared_ptr<PieceStatMan>& getPieceStatMan() const
   {
     return pieceStatMan_;
   }
 
-  void setPieceSelector(const SharedHandle<PieceSelector>& pieceSelector)
+  void setPieceSelector(const std::shared_ptr<PieceSelector>& pieceSelector)
   {
     pieceSelector_ = pieceSelector;
   }
 
-  const SharedHandle<PieceSelector>& getPieceSelector() const
+  const std::shared_ptr<PieceSelector>& getPieceSelector() const
   {
     return pieceSelector_;
   }
diff --git a/src/DiskAdaptor.h b/src/DiskAdaptor.h
index b7d1b1f5..6e46fa4e 100644
--- a/src/DiskAdaptor.h
+++ b/src/DiskAdaptor.h
@@ -39,9 +39,9 @@
 
 #include <string>
 #include <vector>
+#include <memory>
 
 #include "TimeA2.h"
-#include "SharedHandle.h"
 
 namespace aria2 {
 
@@ -78,12 +78,12 @@ public:
     fileEntries_.assign(first, last);
   }
 
-  const std::vector<SharedHandle<FileEntry> >& getFileEntries() const
+  const std::vector<std::shared_ptr<FileEntry> >& getFileEntries() const
   {
     return fileEntries_;
   }
 
-  virtual SharedHandle<FileAllocationIterator> fileAllocationIterator() = 0;
+  virtual std::shared_ptr<FileAllocationIterator> fileAllocationIterator() = 0;
 
   virtual void enableReadOnly() {}
 
@@ -120,7 +120,7 @@ public:
   }
 
 private:
-  std::vector<SharedHandle<FileEntry> > fileEntries_;
+  std::vector<std::shared_ptr<FileEntry> > fileEntries_;
 
   FileAllocationMethod fileAllocationMethod_;
 };
diff --git a/src/DiskWriterFactory.h b/src/DiskWriterFactory.h
index 125ec098..56a8cef0 100644
--- a/src/DiskWriterFactory.h
+++ b/src/DiskWriterFactory.h
@@ -38,8 +38,7 @@
 #include "common.h"
 
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -49,7 +48,7 @@ class DiskWriterFactory {
 public:
   virtual ~DiskWriterFactory() {}
 
-  virtual SharedHandle<DiskWriter> newDiskWriter(const std::string& filename)=0;
+  virtual std::shared_ptr<DiskWriter> newDiskWriter(const std::string& filename)=0;
 };
 
 } // namespace aria2
diff --git a/src/DlAbortEx.cc b/src/DlAbortEx.cc
index 81490ca4..c5de3b93 100644
--- a/src/DlAbortEx.cc
+++ b/src/DlAbortEx.cc
@@ -36,9 +36,9 @@
 
 namespace aria2 {
 
-SharedHandle<Exception> DlAbortEx::copy() const
+std::shared_ptr<Exception> DlAbortEx::copy() const
 {
-  SharedHandle<Exception> e(new DlAbortEx(*this));
+  std::shared_ptr<Exception> e(new DlAbortEx(*this));
   return e;
 }
 
diff --git a/src/DlAbortEx.h b/src/DlAbortEx.h
index 3498b1fb..e49e827d 100644
--- a/src/DlAbortEx.h
+++ b/src/DlAbortEx.h
@@ -40,7 +40,7 @@ namespace aria2 {
 
 class DlAbortEx:public RecoverableException {
 protected:
-  virtual SharedHandle<Exception> copy() const;
+  virtual std::shared_ptr<Exception> copy() const;
 public:
   DlAbortEx(const char* file, int line, const std::string& msg);
 
diff --git a/src/DlRetryEx.cc b/src/DlRetryEx.cc
index 8bbbfa33..98bf7eff 100644
--- a/src/DlRetryEx.cc
+++ b/src/DlRetryEx.cc
@@ -36,9 +36,9 @@
 
 namespace aria2 {
 
-SharedHandle<Exception> DlRetryEx::copy() const
+std::shared_ptr<Exception> DlRetryEx::copy() const
 {
-  SharedHandle<Exception> e(new DlRetryEx(*this));
+  std::shared_ptr<Exception> e(new DlRetryEx(*this));
   return e;
 }
 
diff --git a/src/DlRetryEx.h b/src/DlRetryEx.h
index dcecb357..98a0ff59 100644
--- a/src/DlRetryEx.h
+++ b/src/DlRetryEx.h
@@ -40,7 +40,7 @@ namespace aria2 {
 
 class DlRetryEx:public RecoverableException {
 protected:
-  virtual SharedHandle<Exception> copy() const;
+  virtual std::shared_ptr<Exception> copy() const;
 public:
   DlRetryEx(const char* file, int line, const std::string& msg);
 
diff --git a/src/DownloadCommand.cc b/src/DownloadCommand.cc
index 0c17e83b..b6d7e1cc 100644
--- a/src/DownloadCommand.cc
+++ b/src/DownloadCommand.cc
@@ -81,12 +81,12 @@ const size_t BUFSIZE = 16*1024;
 
 DownloadCommand::DownloadCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& s,
- const SharedHandle<SocketRecvBuffer>& socketRecvBuffer)
+ const std::shared_ptr<SocketCore>& s,
+ const std::shared_ptr<SocketRecvBuffer>& socketRecvBuffer)
   : AbstractCommand(cuid, req, fileEntry, requestGroup, e, s, socketRecvBuffer),
     startupIdleTime_(10),
     lowestDownloadSpeedLimit_(0),
@@ -123,9 +123,9 @@ DownloadCommand::~DownloadCommand() {
 
 namespace {
 void flushWrDiskCacheEntry(WrDiskCache* wrDiskCache,
-                           const SharedHandle<Segment>& segment)
+                           const std::shared_ptr<Segment>& segment)
 {
-  const SharedHandle<Piece>& piece = segment->getPiece();
+  const std::shared_ptr<Piece>& piece = segment->getPiece();
   if(piece->getWrDiskCacheEntry()) {
     piece->flushWrCache(wrDiskCache);
     if(piece->getWrDiskCacheEntry()->getError() !=
@@ -149,9 +149,9 @@ bool DownloadCommand::executeInternal() {
   }
   setReadCheckSocket(getSocket());
 
-  const SharedHandle<DiskAdaptor>& diskAdaptor =
+  const std::shared_ptr<DiskAdaptor>& diskAdaptor =
     getPieceStorage()->getDiskAdaptor();
-  SharedHandle<Segment> segment = getSegments().front();
+  std::shared_ptr<Segment> segment = getSegments().front();
   bool eof = false;
   if(getSocketRecvBuffer()->bufferEmpty()) {
     // Only read from socket when buffer is empty.  Imagine that When
@@ -328,7 +328,7 @@ bool DownloadCommand::prepareForNextSegment() {
     }
 #ifdef ENABLE_MESSAGE_DIGEST
     if(getDownloadContext()->getPieceHashType().empty()) {
-      SharedHandle<CheckIntegrityEntry> entry
+      std::shared_ptr<CheckIntegrityEntry> entry
         (new ChecksumCheckIntegrityEntry(getRequestGroup()));
       if(entry->isValidationReady()) {
         entry->initValidator();
@@ -346,7 +346,7 @@ bool DownloadCommand::prepareForNextSegment() {
     // The number of segments should be 1 in order to pass through the next
     // segment.
     if(getSegments().size() == 1) {
-      SharedHandle<Segment> tempSegment = getSegments().front();
+      std::shared_ptr<Segment> tempSegment = getSegments().front();
       if(!tempSegment->complete()) {
         return prepareForRetry(0);
       }
@@ -355,7 +355,7 @@ bool DownloadCommand::prepareForNextSegment() {
          (tempSegment->getPosition()+tempSegment->getLength())) {
         return prepareForRetry(0);
       }
-      SharedHandle<Segment> nextSegment = getSegmentMan()->getSegmentWithIndex
+      std::shared_ptr<Segment> nextSegment = getSegmentMan()->getSegmentWithIndex
         (getCuid(), tempSegment->getIndex()+1);
       if(!nextSegment) {
         nextSegment = getSegmentMan()->getCleanSegmentIfOwnerIsIdle
@@ -379,7 +379,7 @@ bool DownloadCommand::prepareForNextSegment() {
 
 #ifdef ENABLE_MESSAGE_DIGEST
 
-void DownloadCommand::validatePieceHash(const SharedHandle<Segment>& segment,
+void DownloadCommand::validatePieceHash(const std::shared_ptr<Segment>& segment,
                                         const std::string& expectedHash,
                                         const std::string& actualHash)
 {
@@ -403,14 +403,14 @@ void DownloadCommand::validatePieceHash(const SharedHandle<Segment>& segment,
 #endif // ENABLE_MESSAGE_DIGEST
 
 void DownloadCommand::completeSegment(cuid_t cuid,
-                                      const SharedHandle<Segment>& segment)
+                                      const std::shared_ptr<Segment>& segment)
 {
   flushWrDiskCacheEntry(getPieceStorage()->getWrDiskCache(), segment);
   getSegmentMan()->completeSegment(cuid, segment);
 }
 
 void DownloadCommand::installStreamFilter
-(const SharedHandle<StreamFilter>& streamFilter)
+(const std::shared_ptr<StreamFilter>& streamFilter)
 {
   if(!streamFilter) {
     return;
diff --git a/src/DownloadCommand.h b/src/DownloadCommand.h
index 544da2a6..a36722b2 100644
--- a/src/DownloadCommand.h
+++ b/src/DownloadCommand.h
@@ -51,25 +51,25 @@ class DownloadCommand : public AbstractCommand {
 private:
   time_t startupIdleTime_;
   int lowestDownloadSpeedLimit_;
-  SharedHandle<PeerStat> peerStat_;
+  std::shared_ptr<PeerStat> peerStat_;
 
   bool pieceHashValidationEnabled_;
 
 #ifdef ENABLE_MESSAGE_DIGEST
 
-  SharedHandle<MessageDigest> messageDigest_;
+  std::shared_ptr<MessageDigest> messageDigest_;
 
 #endif // ENABLE_MESSAGE_DIGEST
 
-  void validatePieceHash(const SharedHandle<Segment>& segment,
+  void validatePieceHash(const std::shared_ptr<Segment>& segment,
                          const std::string& expectedPieceHash,
                          const std::string& actualPieceHash);
 
   void checkLowestDownloadSpeed() const;
 
-  void completeSegment(cuid_t cuid, const SharedHandle<Segment>& segment);
+  void completeSegment(cuid_t cuid, const std::shared_ptr<Segment>& segment);
 
-  SharedHandle<StreamFilter> streamFilter_;
+  std::shared_ptr<StreamFilter> streamFilter_;
 
   bool sinkFilterOnly_;
 protected:
@@ -81,20 +81,20 @@ protected:
   virtual int64_t getRequestEndOffset() const = 0;
 public:
   DownloadCommand(cuid_t cuid,
-                  const SharedHandle<Request>& req,
-                  const SharedHandle<FileEntry>& fileEntry,
+                  const std::shared_ptr<Request>& req,
+                  const std::shared_ptr<FileEntry>& fileEntry,
                   RequestGroup* requestGroup,
                   DownloadEngine* e,
-                  const SharedHandle<SocketCore>& s,
-                  const SharedHandle<SocketRecvBuffer>& socketRecvBuffer);
+                  const std::shared_ptr<SocketCore>& s,
+                  const std::shared_ptr<SocketRecvBuffer>& socketRecvBuffer);
   virtual ~DownloadCommand();
 
-  const SharedHandle<StreamFilter>& getStreamFilter() const
+  const std::shared_ptr<StreamFilter>& getStreamFilter() const
   {
     return streamFilter_;
   }
 
-  void installStreamFilter(const SharedHandle<StreamFilter>& streamFilter);
+  void installStreamFilter(const std::shared_ptr<StreamFilter>& streamFilter);
 
   void setStartupIdleTime(time_t startupIdleTime)
   {
diff --git a/src/DownloadContext.cc b/src/DownloadContext.cc
index 1191259a..7bb307e7 100644
--- a/src/DownloadContext.cc
+++ b/src/DownloadContext.cc
@@ -67,7 +67,7 @@ DownloadContext::DownloadContext(int32_t pieceLength,
   downloadStopTime_(0),
   acceptMetalink_(true)
 {
-  SharedHandle<FileEntry> fileEntry(new FileEntry(path, totalLength, 0));
+  std::shared_ptr<FileEntry> fileEntry(new FileEntry(path, totalLength, 0));
   fileEntries_.push_back(fileEntry);
 }
 
@@ -91,19 +91,19 @@ int64_t DownloadContext::calculateSessionTime() const
   return startTime.differenceInMillis(downloadStopTime_);
 }
 
-SharedHandle<FileEntry>
+std::shared_ptr<FileEntry>
 DownloadContext::findFileEntryByOffset(int64_t offset) const
 {
   if(fileEntries_.empty() ||
      (offset > 0 && fileEntries_.back()->getLastOffset() <= offset)) {
-    return SharedHandle<FileEntry>();
+    return std::shared_ptr<FileEntry>();
   }
 
-  SharedHandle<FileEntry> obj(new FileEntry());
+  std::shared_ptr<FileEntry> obj(new FileEntry());
   obj->setOffset(offset);
-  std::vector<SharedHandle<FileEntry> >::const_iterator i =
+  std::vector<std::shared_ptr<FileEntry> >::const_iterator i =
     std::upper_bound(fileEntries_.begin(), fileEntries_.end(), obj,
-                     DerefLess<SharedHandle<FileEntry> >());
+                     DerefLess<std::shared_ptr<FileEntry> >());
   if(i != fileEntries_.end() && (*i)->getOffset() == offset) {
     return *i;
   } else {
@@ -148,17 +148,17 @@ void DownloadContext::setFileFilter(SegList<int>& sgl)
 }
 
 void DownloadContext::setAttribute
-(ContextAttributeType key, const SharedHandle<ContextAttribute>& value)
+(ContextAttributeType key, const std::shared_ptr<ContextAttribute>& value)
 {
   assert(key < MAX_CTX_ATTR);
   attrs_[key] = value;
 }
 
-const SharedHandle<ContextAttribute>& DownloadContext::getAttribute
+const std::shared_ptr<ContextAttribute>& DownloadContext::getAttribute
 (ContextAttributeType key)
 {
   assert(key < MAX_CTX_ATTR);
-  const SharedHandle<ContextAttribute>& attr = attrs_[key];
+  const std::shared_ptr<ContextAttribute>& attr = attrs_[key];
   if(attr) {
     return attr;
   } else {
@@ -170,12 +170,12 @@ const SharedHandle<ContextAttribute>& DownloadContext::getAttribute
 bool DownloadContext::hasAttribute(ContextAttributeType key) const
 {
   assert(key < MAX_CTX_ATTR);
-  return attrs_[key];
+  return attrs_[key].get();
 }
 
 void DownloadContext::releaseRuntimeResource()
 {
-  for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
+  for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i =
         fileEntries_.begin(), eoi = fileEntries_.end(); i != eoi; ++i) {
     (*i)->putBackRequest();
     (*i)->releaseRuntimeResource();
@@ -211,22 +211,22 @@ const std::string& DownloadContext::getBasePath() const
   }
 }
 
-SharedHandle<FileEntry>
+std::shared_ptr<FileEntry>
 DownloadContext::getFirstRequestedFileEntry() const
 {
-  for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
+  for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i =
         fileEntries_.begin(), eoi = fileEntries_.end(); i != eoi; ++i) {
     if((*i)->isRequested()) {
       return *i;
     }
   }
-  return SharedHandle<FileEntry>();
+  return std::shared_ptr<FileEntry>();
 }
 
 size_t DownloadContext::countRequestedFileEntry() const
 {
   size_t numFiles = 0;
-  for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
+  for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i =
         fileEntries_.begin(), eoi = fileEntries_.end(); i != eoi; ++i) {
     if((*i)->isRequested()) {
       ++numFiles;
@@ -274,7 +274,7 @@ void DownloadContext::setBasePath(const std::string& basePath)
   basePath_ = basePath;
 }
 
-void DownloadContext::setSignature(const SharedHandle<Signature>& signature)
+void DownloadContext::setSignature(const std::shared_ptr<Signature>& signature)
 {
   signature_ = signature;
 }
diff --git a/src/DownloadContext.h b/src/DownloadContext.h
index 8ba146e3..ee5df7be 100644
--- a/src/DownloadContext.h
+++ b/src/DownloadContext.h
@@ -40,8 +40,8 @@
 #include <cassert>
 #include <string>
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimerA2.h"
 #include "A2STR.h"
 #include "ValueBase.h"
@@ -58,7 +58,7 @@ class FileEntry;
 class DownloadContext
 {
 private:
-  std::vector<SharedHandle<FileEntry> > fileEntries_;
+  std::vector<std::shared_ptr<FileEntry> > fileEntries_;
 
   std::vector<std::string> pieceHashes_;
 
@@ -78,13 +78,13 @@ private:
 
   RequestGroup* ownerRequestGroup_;
 
-  std::vector<SharedHandle<ContextAttribute> > attrs_;
+  std::vector<std::shared_ptr<ContextAttribute> > attrs_;
 
   NetStat netStat_;
 
   Timer downloadStopTime_;
 
-  SharedHandle<Signature> signature_;
+  std::shared_ptr<Signature> signature_;
   // This member variable is required to avoid to use parse Metalink
   // (including both Metalink XML and Metalink/HTTP) twice.
   bool acceptMetalink_;
@@ -123,12 +123,12 @@ public:
 
   void markTotalLengthIsKnown() { knowsTotalLength_ = true; }
 
-  const std::vector<SharedHandle<FileEntry> >& getFileEntries() const
+  const std::vector<std::shared_ptr<FileEntry> >& getFileEntries() const
   {
     return fileEntries_;
   }
 
-  const SharedHandle<FileEntry>& getFirstFileEntry() const
+  const std::shared_ptr<FileEntry>& getFirstFileEntry() const
   {
     assert(!fileEntries_.empty());
     return fileEntries_[0];
@@ -136,8 +136,8 @@ public:
 
   // This function returns first FileEntry whose isRequested() returns
   // true.  If there is no such FileEntry, returns
-  // SharedHandle<FileEntry>().
-  SharedHandle<FileEntry> getFirstRequestedFileEntry() const;
+  // std::shared_ptr<FileEntry>().
+  std::shared_ptr<FileEntry> getFirstRequestedFileEntry() const;
 
   size_t countRequestedFileEntry() const;
 
@@ -169,9 +169,9 @@ public:
 
   void setBasePath(const std::string& basePath);
 
-  const SharedHandle<Signature>& getSignature() const { return signature_; }
+  const std::shared_ptr<Signature>& getSignature() const { return signature_; }
 
-  void setSignature(const SharedHandle<Signature>& signature);
+  void setSignature(const std::shared_ptr<Signature>& signature);
 
   RequestGroup* getOwnerRequestGroup() { return ownerRequestGroup_; }
 
@@ -204,9 +204,9 @@ public:
   }
 
   void setAttribute
-  (ContextAttributeType key, const SharedHandle<ContextAttribute>& value);
+  (ContextAttributeType key, const std::shared_ptr<ContextAttribute>& value);
 
-  const SharedHandle<ContextAttribute>& getAttribute(ContextAttributeType key);
+  const std::shared_ptr<ContextAttribute>& getAttribute(ContextAttributeType key);
 
   bool hasAttribute(ContextAttributeType key) const;
 
@@ -221,9 +221,9 @@ public:
 
   int64_t calculateSessionTime() const;
 
-  // Returns FileEntry at given offset. SharedHandle<FileEntry>() is
+  // Returns FileEntry at given offset. std::shared_ptr<FileEntry>() is
   // returned if no such FileEntry is found.
-  SharedHandle<FileEntry> findFileEntryByOffset(int64_t offset) const;
+  std::shared_ptr<FileEntry> findFileEntryByOffset(int64_t offset) const;
 
   void releaseRuntimeResource();
 
diff --git a/src/DownloadEngine.cc b/src/DownloadEngine.cc
index 18aa963b..071d2340 100644
--- a/src/DownloadEngine.cc
+++ b/src/DownloadEngine.cc
@@ -86,7 +86,7 @@ volatile sig_atomic_t globalHaltRequested = 0;
 
 } // namespace global
 
-DownloadEngine::DownloadEngine(const SharedHandle<EventPoll>& eventPoll)
+DownloadEngine::DownloadEngine(const std::shared_ptr<EventPoll>& eventPoll)
   : eventPoll_(eventPoll),
     haltRequested_(0),
     noWait_(true),
@@ -186,28 +186,28 @@ void DownloadEngine::waitData()
   eventPoll_->poll(tv);
 }
 
-bool DownloadEngine::addSocketForReadCheck(const SharedHandle<SocketCore>& socket,
+bool DownloadEngine::addSocketForReadCheck(const std::shared_ptr<SocketCore>& socket,
                                            Command* command)
 {
   return eventPoll_->addEvents(socket->getSockfd(), command,
                                EventPoll::EVENT_READ);
 }
 
-bool DownloadEngine::deleteSocketForReadCheck(const SharedHandle<SocketCore>& socket,
+bool DownloadEngine::deleteSocketForReadCheck(const std::shared_ptr<SocketCore>& socket,
                                               Command* command)
 {
   return eventPoll_->deleteEvents(socket->getSockfd(), command,
                                   EventPoll::EVENT_READ);
 }
 
-bool DownloadEngine::addSocketForWriteCheck(const SharedHandle<SocketCore>& socket,
+bool DownloadEngine::addSocketForWriteCheck(const std::shared_ptr<SocketCore>& socket,
                                             Command* command)
 {
   return eventPoll_->addEvents(socket->getSockfd(), command,
                                EventPoll::EVENT_WRITE);
 }
 
-bool DownloadEngine::deleteSocketForWriteCheck(const SharedHandle<SocketCore>& socket,
+bool DownloadEngine::deleteSocketForWriteCheck(const std::shared_ptr<SocketCore>& socket,
                                                Command* command)
 {
   return eventPoll_->deleteEvents(socket->getSockfd(), command,
@@ -258,20 +258,20 @@ void DownloadEngine::requestForceHalt()
   requestGroupMan_->forceHalt();
 }
 
-void DownloadEngine::setStatCalc(const SharedHandle<StatCalc>& statCalc)
+void DownloadEngine::setStatCalc(const std::shared_ptr<StatCalc>& statCalc)
 {
   statCalc_ = statCalc;
 }
 
 #ifdef ENABLE_ASYNC_DNS
 bool DownloadEngine::addNameResolverCheck
-(const SharedHandle<AsyncNameResolver>& resolver, Command* command)
+(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
   return eventPoll_->addNameResolver(resolver, command);
 }
 
 bool DownloadEngine::deleteNameResolverCheck
-(const SharedHandle<AsyncNameResolver>& resolver, Command* command)
+(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
   return eventPoll_->deleteNameResolver(resolver, command);
 }
@@ -336,7 +336,7 @@ void DownloadEngine::poolSocket
  const std::string& username,
  const std::string& proxyhost,
  uint16_t proxyport,
- const SharedHandle<SocketCore>& sock,
+ const std::shared_ptr<SocketCore>& sock,
  const std::string& options,
  time_t timeout)
 {
@@ -349,7 +349,7 @@ void DownloadEngine::poolSocket
  uint16_t port,
  const std::string& proxyhost,
  uint16_t proxyport,
- const SharedHandle<SocketCore>& sock,
+ const std::shared_ptr<SocketCore>& sock,
  time_t timeout)
 {
   SocketPoolEntry e(sock, timeout);
@@ -358,7 +358,7 @@ void DownloadEngine::poolSocket
 
 namespace {
 bool getPeerInfo(std::pair<std::string, uint16_t>& res,
-                 const SharedHandle<SocketCore>& socket)
+                 const std::shared_ptr<SocketCore>& socket)
 {
   try {
     socket->getPeerInfo(res);
@@ -372,9 +372,9 @@ bool getPeerInfo(std::pair<std::string, uint16_t>& res,
 }
 } // namespace
 
-void DownloadEngine::poolSocket(const SharedHandle<Request>& request,
-                                const SharedHandle<Request>& proxyRequest,
-                                const SharedHandle<SocketCore>& socket,
+void DownloadEngine::poolSocket(const std::shared_ptr<Request>& request,
+                                const std::shared_ptr<Request>& proxyRequest,
+                                const std::shared_ptr<SocketCore>& socket,
                                 time_t timeout)
 {
   if(!proxyRequest) {
@@ -392,10 +392,10 @@ void DownloadEngine::poolSocket(const SharedHandle<Request>& request,
 }
 
 void DownloadEngine::poolSocket
-(const SharedHandle<Request>& request,
+(const std::shared_ptr<Request>& request,
  const std::string& username,
- const SharedHandle<Request>& proxyRequest,
- const SharedHandle<SocketCore>& socket,
+ const std::shared_ptr<Request>& proxyRequest,
+ const std::shared_ptr<SocketCore>& socket,
  const std::string& options,
  time_t timeout)
 {
@@ -432,12 +432,12 @@ DownloadEngine::findSocketPoolEntry(const std::string& key)
   return socketPool_.end();
 }
 
-SharedHandle<SocketCore>
+std::shared_ptr<SocketCore>
 DownloadEngine::popPooledSocket
 (const std::string& ipaddr, uint16_t port,
  const std::string& proxyhost, uint16_t proxyport)
 {
-  SharedHandle<SocketCore> s;
+  std::shared_ptr<SocketCore> s;
   std::multimap<std::string, SocketPoolEntry>::iterator i =
     findSocketPoolEntry
     (createSockPoolKey(ipaddr, port, A2STR::NIL, proxyhost, proxyport));
@@ -448,14 +448,14 @@ DownloadEngine::popPooledSocket
   return s;
 }
 
-SharedHandle<SocketCore>
+std::shared_ptr<SocketCore>
 DownloadEngine::popPooledSocket
 (std::string& options,
  const std::string& ipaddr, uint16_t port,
  const std::string& username,
  const std::string& proxyhost, uint16_t proxyport)
 {
-  SharedHandle<SocketCore> s;
+  std::shared_ptr<SocketCore> s;
   std::multimap<std::string, SocketPoolEntry>::iterator i =
     findSocketPoolEntry
     (createSockPoolKey(ipaddr, port, username, proxyhost, proxyport));
@@ -467,11 +467,11 @@ DownloadEngine::popPooledSocket
   return s;
 }
 
-SharedHandle<SocketCore>
+std::shared_ptr<SocketCore>
 DownloadEngine::popPooledSocket
 (const std::vector<std::string>& ipaddrs, uint16_t port)
 {
-  SharedHandle<SocketCore> s;
+  std::shared_ptr<SocketCore> s;
   for(std::vector<std::string>::const_iterator i = ipaddrs.begin(),
         eoi = ipaddrs.end(); i != eoi; ++i) {
     s = popPooledSocket(*i, port, A2STR::NIL, 0);
@@ -482,13 +482,13 @@ DownloadEngine::popPooledSocket
   return s;
 }
 
-SharedHandle<SocketCore>
+std::shared_ptr<SocketCore>
 DownloadEngine::popPooledSocket
 (std::string& options,
  const std::vector<std::string>& ipaddrs, uint16_t port,
  const std::string& username)
 {
-  SharedHandle<SocketCore> s;
+  std::shared_ptr<SocketCore> s;
   for(std::vector<std::string>::const_iterator i = ipaddrs.begin(),
         eoi = ipaddrs.end(); i != eoi; ++i) {
     s = popPooledSocket(options, *i, port, username, A2STR::NIL, 0);
@@ -500,7 +500,7 @@ DownloadEngine::popPooledSocket
 }
 
 DownloadEngine::SocketPoolEntry::SocketPoolEntry
-(const SharedHandle<SocketCore>& socket,
+(const std::shared_ptr<SocketCore>& socket,
  const std::string& options,
  time_t timeout)
   : socket_(socket),
@@ -509,7 +509,7 @@ DownloadEngine::SocketPoolEntry::SocketPoolEntry
 {}
 
 DownloadEngine::SocketPoolEntry::SocketPoolEntry
-(const SharedHandle<SocketCore>& socket, time_t timeout)
+(const std::shared_ptr<SocketCore>& socket, time_t timeout)
   : socket_(socket),
     timeout_(timeout)
 {}
@@ -551,7 +551,7 @@ void DownloadEngine::removeCachedIPAddress
 }
 
 void DownloadEngine::setAuthConfigFactory
-(const SharedHandle<AuthConfigFactory>& factory)
+(const std::shared_ptr<AuthConfigFactory>& factory)
 {
   authConfigFactory_ = factory;
 }
@@ -572,19 +572,19 @@ void DownloadEngine::addCommand(Command* command)
 }
 
 void DownloadEngine::setRequestGroupMan
-(const SharedHandle<RequestGroupMan>& rgman)
+(const std::shared_ptr<RequestGroupMan>& rgman)
 {
   requestGroupMan_ = rgman;
 }
 
 void DownloadEngine::setFileAllocationMan
-(const SharedHandle<FileAllocationMan>& faman)
+(const std::shared_ptr<FileAllocationMan>& faman)
 {
   fileAllocationMan_ = faman;
 }
 
 void DownloadEngine::setCheckIntegrityMan
-(const SharedHandle<CheckIntegrityMan>& ciman)
+(const std::shared_ptr<CheckIntegrityMan>& ciman)
 {
   checkIntegrityMan_ = ciman;
 }
@@ -604,7 +604,7 @@ void DownloadEngine::setAsyncDNSServers(ares_addr_node* asyncDNSServers)
 
 #ifdef ENABLE_WEBSOCKET
 void DownloadEngine::setWebSocketSessionMan
-(const SharedHandle<rpc::WebSocketSessionMan>& wsman)
+(const std::shared_ptr<rpc::WebSocketSessionMan>& wsman)
 {
   webSocketSessionMan_ = wsman;
 }
diff --git a/src/DownloadEngine.h b/src/DownloadEngine.h
index b26d3dda..242769fe 100644
--- a/src/DownloadEngine.h
+++ b/src/DownloadEngine.h
@@ -41,8 +41,8 @@
 #include <deque>
 #include <map>
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "a2netcompat.h"
 #include "TimerA2.h"
 #include "a2io.h"
@@ -80,15 +80,15 @@ private:
 
   std::string sessionId_;
 
-  SharedHandle<EventPoll> eventPoll_;
+  std::shared_ptr<EventPoll> eventPoll_;
 
-  SharedHandle<StatCalc> statCalc_;
+  std::shared_ptr<StatCalc> statCalc_;
 
   int haltRequested_;
 
   class SocketPoolEntry {
   private:
-    SharedHandle<SocketCore> socket_;
+    std::shared_ptr<SocketCore> socket_;
     // protocol specific option string
     std::string options_;
 
@@ -96,18 +96,18 @@ private:
 
     Timer registeredTime_;
   public:
-    SocketPoolEntry(const SharedHandle<SocketCore>& socket,
+    SocketPoolEntry(const std::shared_ptr<SocketCore>& socket,
                     const std::string& option,
                     time_t timeout);
 
-    SocketPoolEntry(const SharedHandle<SocketCore>& socket,
+    SocketPoolEntry(const std::shared_ptr<SocketCore>& socket,
                     time_t timeout);
 
     ~SocketPoolEntry();
 
     bool isTimeout() const;
 
-    const SharedHandle<SocketCore>& getSocket() const
+    const std::shared_ptr<SocketCore>& getSocket() const
     {
       return socket_;
     }
@@ -133,10 +133,10 @@ private:
 
   std::deque<Command*> routineCommands_;
 
-  SharedHandle<CookieStorage> cookieStorage_;
+  std::shared_ptr<CookieStorage> cookieStorage_;
 
 #ifdef ENABLE_BITTORRENT
-  SharedHandle<BtRegistry> btRegistry_;
+  std::shared_ptr<BtRegistry> btRegistry_;
 #endif // ENABLE_BITTORRENT
 
   CUIDCounter cuidCounter_;
@@ -145,12 +145,12 @@ private:
   ares_addr_node* asyncDNSServers_;
 #endif // HAVE_ARES_ADDR_NODE
 
-  SharedHandle<DNSCache> dnsCache_;
+  std::shared_ptr<DNSCache> dnsCache_;
 
-  SharedHandle<AuthConfigFactory> authConfigFactory_;
+  std::shared_ptr<AuthConfigFactory> authConfigFactory_;
 
 #ifdef ENABLE_WEBSOCKET
-  SharedHandle<rpc::WebSocketSessionMan> webSocketSessionMan_;
+  std::shared_ptr<rpc::WebSocketSessionMan> webSocketSessionMan_;
 #endif // ENABLE_WEBSOCKET
 
   /**
@@ -168,12 +168,12 @@ private:
   findSocketPoolEntry(const std::string& key);
 
   std::deque<Command*> commands_;
-  SharedHandle<RequestGroupMan> requestGroupMan_;
-  SharedHandle<FileAllocationMan> fileAllocationMan_;
-  SharedHandle<CheckIntegrityMan> checkIntegrityMan_;
+  std::shared_ptr<RequestGroupMan> requestGroupMan_;
+  std::shared_ptr<FileAllocationMan> fileAllocationMan_;
+  std::shared_ptr<CheckIntegrityMan> checkIntegrityMan_;
   Option* option_;
 public:
-  DownloadEngine(const SharedHandle<EventPoll>& eventPoll);
+  DownloadEngine(const std::shared_ptr<EventPoll>& eventPoll);
 
   ~DownloadEngine();
 
@@ -183,20 +183,20 @@ public:
   // processed. Otherwise, returns 0.
   int run(bool oneshot=false);
 
-  bool addSocketForReadCheck(const SharedHandle<SocketCore>& socket,
+  bool addSocketForReadCheck(const std::shared_ptr<SocketCore>& socket,
                              Command* command);
-  bool deleteSocketForReadCheck(const SharedHandle<SocketCore>& socket,
+  bool deleteSocketForReadCheck(const std::shared_ptr<SocketCore>& socket,
                                 Command* command);
-  bool addSocketForWriteCheck(const SharedHandle<SocketCore>& socket,
+  bool addSocketForWriteCheck(const std::shared_ptr<SocketCore>& socket,
                               Command* command);
-  bool deleteSocketForWriteCheck(const SharedHandle<SocketCore>& socket,
+  bool deleteSocketForWriteCheck(const std::shared_ptr<SocketCore>& socket,
                                  Command* command);
 
 #ifdef ENABLE_ASYNC_DNS
 
-  bool addNameResolverCheck(const SharedHandle<AsyncNameResolver>& resolver,
+  bool addNameResolverCheck(const std::shared_ptr<AsyncNameResolver>& resolver,
                             Command* command);
-  bool deleteNameResolverCheck(const SharedHandle<AsyncNameResolver>& resolver,
+  bool deleteNameResolverCheck(const std::shared_ptr<AsyncNameResolver>& resolver,
                                Command* command);
 #endif // ENABLE_ASYNC_DNS
 
@@ -204,26 +204,26 @@ public:
 
   void addCommand(Command* command);
 
-  const SharedHandle<RequestGroupMan>& getRequestGroupMan() const
+  const std::shared_ptr<RequestGroupMan>& getRequestGroupMan() const
   {
     return requestGroupMan_;
   }
 
-  void setRequestGroupMan(const SharedHandle<RequestGroupMan>& rgman);
+  void setRequestGroupMan(const std::shared_ptr<RequestGroupMan>& rgman);
 
-  const SharedHandle<FileAllocationMan>& getFileAllocationMan() const
+  const std::shared_ptr<FileAllocationMan>& getFileAllocationMan() const
   {
     return fileAllocationMan_;
   }
 
-  void setFileAllocationMan(const SharedHandle<FileAllocationMan>& faman);
+  void setFileAllocationMan(const std::shared_ptr<FileAllocationMan>& faman);
 
-  const SharedHandle<CheckIntegrityMan>& getCheckIntegrityMan() const
+  const std::shared_ptr<CheckIntegrityMan>& getCheckIntegrityMan() const
   {
     return checkIntegrityMan_;
   }
 
-  void setCheckIntegrityMan(const SharedHandle<CheckIntegrityMan>& ciman);
+  void setCheckIntegrityMan(const std::shared_ptr<CheckIntegrityMan>& ciman);
 
   Option* getOption() const
   {
@@ -235,7 +235,7 @@ public:
     option_ = op;
   }
 
-  void setStatCalc(const SharedHandle<StatCalc>& statCalc);
+  void setStatCalc(const std::shared_ptr<StatCalc>& statCalc);
 
   bool isHaltRequested() const
   {
@@ -258,57 +258,57 @@ public:
   void poolSocket(const std::string& ipaddr, uint16_t port,
                   const std::string& username,
                   const std::string& proxyhost, uint16_t proxyport,
-                  const SharedHandle<SocketCore>& sock,
+                  const std::shared_ptr<SocketCore>& sock,
                   const std::string& options,
                   time_t timeout = 15);
 
-  void poolSocket(const SharedHandle<Request>& request,
+  void poolSocket(const std::shared_ptr<Request>& request,
                   const std::string& username,
-                  const SharedHandle<Request>& proxyRequest,
-                  const SharedHandle<SocketCore>& socket,
+                  const std::shared_ptr<Request>& proxyRequest,
+                  const std::shared_ptr<SocketCore>& socket,
                   const std::string& options,
                   time_t timeout = 15);
 
   void poolSocket(const std::string& ipaddr, uint16_t port,
                   const std::string& proxyhost, uint16_t proxyport,
-                  const SharedHandle<SocketCore>& sock,
+                  const std::shared_ptr<SocketCore>& sock,
                   time_t timeout = 15);
 
-  void poolSocket(const SharedHandle<Request>& request,
-                  const SharedHandle<Request>& proxyRequest,
-                  const SharedHandle<SocketCore>& socket,
+  void poolSocket(const std::shared_ptr<Request>& request,
+                  const std::shared_ptr<Request>& proxyRequest,
+                  const std::shared_ptr<SocketCore>& socket,
                   time_t timeout = 15);
 
-  SharedHandle<SocketCore> popPooledSocket
+  std::shared_ptr<SocketCore> popPooledSocket
   (const std::string& ipaddr,
    uint16_t port,
    const std::string& proxyhost, uint16_t proxyport);
 
-  SharedHandle<SocketCore> popPooledSocket
+  std::shared_ptr<SocketCore> popPooledSocket
   (std::string& options,
    const std::string& ipaddr,
    uint16_t port,
    const std::string& username,
    const std::string& proxyhost, uint16_t proxyport);
 
-  SharedHandle<SocketCore>
+  std::shared_ptr<SocketCore>
   popPooledSocket
   (const std::vector<std::string>& ipaddrs, uint16_t port);
 
-  SharedHandle<SocketCore>
+  std::shared_ptr<SocketCore>
   popPooledSocket
   (std::string& options,
    const std::vector<std::string>& ipaddrs,
    uint16_t port,
    const std::string& username);
 
-  const SharedHandle<CookieStorage>& getCookieStorage() const
+  const std::shared_ptr<CookieStorage>& getCookieStorage() const
   {
     return cookieStorage_;
   }
 
 #ifdef ENABLE_BITTORRENT
-  const SharedHandle<BtRegistry>& getBtRegistry() const
+  const std::shared_ptr<BtRegistry>& getBtRegistry() const
   {
     return btRegistry_;
   }
@@ -334,9 +334,9 @@ public:
 
   void removeCachedIPAddress(const std::string& hostname, uint16_t port);
 
-  void setAuthConfigFactory(const SharedHandle<AuthConfigFactory>& factory);
+  void setAuthConfigFactory(const std::shared_ptr<AuthConfigFactory>& factory);
 
-  const SharedHandle<AuthConfigFactory>& getAuthConfigFactory() const
+  const std::shared_ptr<AuthConfigFactory>& getAuthConfigFactory() const
   {
     return authConfigFactory_;
   }
@@ -359,8 +359,8 @@ public:
 
 #ifdef ENABLE_WEBSOCKET
   void setWebSocketSessionMan
-  (const SharedHandle<rpc::WebSocketSessionMan>& wsman);
-  const SharedHandle<rpc::WebSocketSessionMan>& getWebSocketSessionMan() const
+  (const std::shared_ptr<rpc::WebSocketSessionMan>& wsman);
+  const std::shared_ptr<rpc::WebSocketSessionMan>& getWebSocketSessionMan() const
   {
     return webSocketSessionMan_;
   }
diff --git a/src/DownloadEngineFactory.cc b/src/DownloadEngineFactory.cc
index 164b1b15..8c7ace30 100644
--- a/src/DownloadEngineFactory.cc
+++ b/src/DownloadEngineFactory.cc
@@ -84,17 +84,17 @@ namespace aria2 {
 
 DownloadEngineFactory::DownloadEngineFactory() {}
 
-SharedHandle<DownloadEngine>
+std::shared_ptr<DownloadEngine>
 DownloadEngineFactory::newDownloadEngine
-(Option* op, const std::vector<SharedHandle<RequestGroup> >& requestGroups)
+(Option* op, const std::vector<std::shared_ptr<RequestGroup> >& requestGroups)
 {
   const size_t MAX_CONCURRENT_DOWNLOADS =
     op->getAsInt(PREF_MAX_CONCURRENT_DOWNLOADS);
-  SharedHandle<EventPoll> eventPoll;
+  std::shared_ptr<EventPoll> eventPoll;
   const std::string& pollMethod = op->get(PREF_EVENT_POLL);
 #ifdef HAVE_LIBUV
   if (pollMethod == V_LIBUV) {
-    SharedHandle<LibuvEventPoll> ep(new LibuvEventPoll());
+    std::shared_ptr<LibuvEventPoll> ep(new LibuvEventPoll());
     if (!ep->good()) {
       throw DL_ABORT_EX("Initializing LibuvEventPoll failed."
                         " Try --event-poll=select");
@@ -105,7 +105,7 @@ DownloadEngineFactory::newDownloadEngine
 #endif // HAVE_LIBUV
 #ifdef HAVE_EPOLL
   if(pollMethod == V_EPOLL) {
-    SharedHandle<EpollEventPoll> ep(new EpollEventPoll());
+    std::shared_ptr<EpollEventPoll> ep(new EpollEventPoll());
     if(ep->good()) {
       eventPoll = ep;
     } else {
@@ -116,7 +116,7 @@ DownloadEngineFactory::newDownloadEngine
 #endif // HAVE_EPLL
 #ifdef HAVE_KQUEUE
     if(pollMethod == V_KQUEUE) {
-      SharedHandle<KqueueEventPoll> kp(new KqueueEventPoll());
+      std::shared_ptr<KqueueEventPoll> kp(new KqueueEventPoll());
       if(kp->good()) {
         eventPoll = kp;
       } else {
@@ -127,7 +127,7 @@ DownloadEngineFactory::newDownloadEngine
 #endif // HAVE_KQUEUE
 #ifdef HAVE_PORT_ASSOCIATE
       if(pollMethod == V_PORT) {
-        SharedHandle<PortEventPoll> pp(new PortEventPoll());
+        std::shared_ptr<PortEventPoll> pp(new PortEventPoll());
         if(pp->good()) {
           eventPoll = pp;
         } else {
@@ -146,19 +146,19 @@ DownloadEngineFactory::newDownloadEngine
           } else {
             abort();
           }
-  SharedHandle<DownloadEngine> e(new DownloadEngine(eventPoll));
+  std::shared_ptr<DownloadEngine> e(new DownloadEngine(eventPoll));
   e->setOption(op);
 
-  SharedHandle<RequestGroupMan>
+  std::shared_ptr<RequestGroupMan>
     requestGroupMan(new RequestGroupMan(requestGroups, MAX_CONCURRENT_DOWNLOADS,
                                         op));
   requestGroupMan->initWrDiskCache();
   e->setRequestGroupMan(requestGroupMan);
   e->setFileAllocationMan
-    (SharedHandle<FileAllocationMan>(new FileAllocationMan()));
+    (std::shared_ptr<FileAllocationMan>(new FileAllocationMan()));
 #ifdef ENABLE_MESSAGE_DIGEST
   e->setCheckIntegrityMan
-    (SharedHandle<CheckIntegrityMan>(new CheckIntegrityMan()));
+    (std::shared_ptr<CheckIntegrityMan>(new CheckIntegrityMan()));
 #endif // ENABLE_MESSAGE_DIGEST
   e->addRoutineCommand(new FillRequestGroupCommand(e->newCUID(), e.get()));
   e->addRoutineCommand(new FileAllocationDispatcherCommand
diff --git a/src/DownloadEngineFactory.h b/src/DownloadEngineFactory.h
index 1d42a252..14c75b5a 100644
--- a/src/DownloadEngineFactory.h
+++ b/src/DownloadEngineFactory.h
@@ -38,8 +38,7 @@
 #include "common.h"
 
 #include <vector>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -51,9 +50,9 @@ class DownloadEngineFactory {
 public:
   DownloadEngineFactory();
 
-  SharedHandle<DownloadEngine>
+  std::shared_ptr<DownloadEngine>
   newDownloadEngine
-  (Option* op, const std::vector<SharedHandle<RequestGroup> >& requestGroups);
+  (Option* op, const std::vector<std::shared_ptr<RequestGroup> >& requestGroups);
 };
 
 } // namespace aria2
diff --git a/src/DownloadFailureException.cc b/src/DownloadFailureException.cc
index 90411460..07ce3da9 100644
--- a/src/DownloadFailureException.cc
+++ b/src/DownloadFailureException.cc
@@ -36,9 +36,9 @@
 
 namespace aria2 {
 
-SharedHandle<Exception> DownloadFailureException::copy() const
+std::shared_ptr<Exception> DownloadFailureException::copy() const
 {
-  SharedHandle<Exception> e(new DownloadFailureException(*this));
+  std::shared_ptr<Exception> e(new DownloadFailureException(*this));
   return e;
 }
 
diff --git a/src/DownloadFailureException.h b/src/DownloadFailureException.h
index a4f29206..2d147a34 100644
--- a/src/DownloadFailureException.h
+++ b/src/DownloadFailureException.h
@@ -44,7 +44,7 @@ namespace aria2 {
  */
 class DownloadFailureException:public RecoverableException {
 protected:
-  virtual SharedHandle<Exception> copy() const;
+  virtual std::shared_ptr<Exception> copy() const;
 public:
   DownloadFailureException(const char* file, int line, const std::string& msg);
 
diff --git a/src/DownloadHandler.cc b/src/DownloadHandler.cc
index bde2b746..48b53636 100644
--- a/src/DownloadHandler.cc
+++ b/src/DownloadHandler.cc
@@ -49,7 +49,7 @@ bool DownloadHandler::canHandle(const RequestGroup* requestGroup) const
 }
 
 void DownloadHandler::setCriteria
-(const SharedHandle<RequestGroupCriteria>& criteria)
+(const std::shared_ptr<RequestGroupCriteria>& criteria)
 {
   criteria_ = criteria;
 }
diff --git a/src/DownloadHandler.h b/src/DownloadHandler.h
index a042eec7..220a126f 100644
--- a/src/DownloadHandler.h
+++ b/src/DownloadHandler.h
@@ -38,8 +38,7 @@
 #include "common.h"
 
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -49,7 +48,7 @@ class RequestGroupCriteria;
 class DownloadHandler
 {
 private:
-  SharedHandle<RequestGroupCriteria> criteria_;
+  std::shared_ptr<RequestGroupCriteria> criteria_;
 public:
   DownloadHandler();
 
@@ -57,7 +56,7 @@ public:
 
   bool canHandle(const RequestGroup* requestGroup) const;
 
-  void setCriteria(const SharedHandle<RequestGroupCriteria>& criteria);
+  void setCriteria(const std::shared_ptr<RequestGroupCriteria>& criteria);
 };
 
 } // namespace aria2
diff --git a/src/DownloadHandlerFactory.cc b/src/DownloadHandlerFactory.cc
index 7ca0a904..3263fc71 100644
--- a/src/DownloadHandlerFactory.cc
+++ b/src/DownloadHandlerFactory.cc
@@ -44,35 +44,35 @@ namespace aria2 {
 
 #ifdef ENABLE_METALINK
 
-SharedHandle<PreDownloadHandler>
+std::shared_ptr<PreDownloadHandler>
 DownloadHandlerFactory::metalinkPreDownloadHandler_;
 
-SharedHandle<PostDownloadHandler>
+std::shared_ptr<PostDownloadHandler>
 DownloadHandlerFactory::metalinkPostDownloadHandler_;
 
 #endif // ENABLE_METALINK
 
 #ifdef ENABLE_BITTORRENT
 
-SharedHandle<PreDownloadHandler>
+std::shared_ptr<PreDownloadHandler>
 DownloadHandlerFactory::btPreDownloadHandler_;
 
-SharedHandle<PostDownloadHandler>
+std::shared_ptr<PostDownloadHandler>
 DownloadHandlerFactory::btPostDownloadHandler_;
 
-SharedHandle<PostDownloadHandler>
+std::shared_ptr<PostDownloadHandler>
 DownloadHandlerFactory::btMetadataPostDownloadHandler_;
 #endif // ENABLE_BITTORRENT
 
 #ifdef ENABLE_METALINK
 
-SharedHandle<PreDownloadHandler>
+std::shared_ptr<PreDownloadHandler>
 DownloadHandlerFactory::getMetalinkPreDownloadHandler()
 {
   if(!metalinkPreDownloadHandler_) {
     metalinkPreDownloadHandler_.reset(new MemoryBufferPreDownloadHandler());
 
-    SharedHandle<RequestGroupCriteria> criteria
+    std::shared_ptr<RequestGroupCriteria> criteria
       (new ContentTypeRequestGroupCriteria
        (getMetalinkContentTypes(), getMetalinkExtensions()));
     metalinkPreDownloadHandler_->setCriteria(criteria);
@@ -80,7 +80,7 @@ DownloadHandlerFactory::getMetalinkPreDownloadHandler()
   return metalinkPreDownloadHandler_;
 }
 
-SharedHandle<PostDownloadHandler>
+std::shared_ptr<PostDownloadHandler>
 DownloadHandlerFactory::getMetalinkPostDownloadHandler()
 {
   if(!metalinkPostDownloadHandler_) {
@@ -93,14 +93,14 @@ DownloadHandlerFactory::getMetalinkPostDownloadHandler()
 
 #ifdef ENABLE_BITTORRENT
 
-SharedHandle<PreDownloadHandler>
+std::shared_ptr<PreDownloadHandler>
 DownloadHandlerFactory::getBtPreDownloadHandler()
 {
   if(!btPreDownloadHandler_) {
     btPreDownloadHandler_.reset
       (new bittorrent::MemoryBencodePreDownloadHandler());
 
-    SharedHandle<RequestGroupCriteria> criteria
+    std::shared_ptr<RequestGroupCriteria> criteria
       (new ContentTypeRequestGroupCriteria
        (getBtContentTypes(), getBtExtensions()));
     btPreDownloadHandler_->setCriteria(criteria);
@@ -108,7 +108,7 @@ DownloadHandlerFactory::getBtPreDownloadHandler()
   return btPreDownloadHandler_;
 }
 
-SharedHandle<PostDownloadHandler>
+std::shared_ptr<PostDownloadHandler>
 DownloadHandlerFactory::getBtPostDownloadHandler()
 {
   if(!btPostDownloadHandler_) {
@@ -117,7 +117,7 @@ DownloadHandlerFactory::getBtPostDownloadHandler()
   return btPostDownloadHandler_;
 }
 
-SharedHandle<PostDownloadHandler>
+std::shared_ptr<PostDownloadHandler>
 DownloadHandlerFactory::getUTMetadataPostDownloadHandler()
 {
   if(!btMetadataPostDownloadHandler_) {
diff --git a/src/DownloadHandlerFactory.h b/src/DownloadHandlerFactory.h
index 34c7cd23..5aff1f89 100644
--- a/src/DownloadHandlerFactory.h
+++ b/src/DownloadHandlerFactory.h
@@ -36,7 +36,9 @@
 #define D_DOWNLOAD_HANDLER_FACTORY_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "MemoryBufferPreDownloadHandler.h"
 #ifdef ENABLE_BITTORRENT
 #  include "MemoryBencodePreDownloadHandler.h"
@@ -56,40 +58,40 @@ class DownloadHandlerFactory
 {
 private:
 #ifdef ENABLE_METALINK
-  static SharedHandle<PreDownloadHandler>
+  static std::shared_ptr<PreDownloadHandler>
   metalinkPreDownloadHandler_;
 
-  static SharedHandle<PostDownloadHandler>
+  static std::shared_ptr<PostDownloadHandler>
   metalinkPostDownloadHandler_;
 #endif // ENABLE_METALINK
 
 #ifdef ENABLE_BITTORRENT
-  static SharedHandle<PreDownloadHandler>
+  static std::shared_ptr<PreDownloadHandler>
   btPreDownloadHandler_;
 
-  static SharedHandle<PostDownloadHandler>
+  static std::shared_ptr<PostDownloadHandler>
   btPostDownloadHandler_;
 
-  static SharedHandle<PostDownloadHandler>
+  static std::shared_ptr<PostDownloadHandler>
   btMetadataPostDownloadHandler_;
 #endif // ENABLE_BITTORRENT
 public:
 #ifdef ENABLE_METALINK
-  static SharedHandle<PreDownloadHandler>
+  static std::shared_ptr<PreDownloadHandler>
   getMetalinkPreDownloadHandler();
 
-  static SharedHandle<PostDownloadHandler>
+  static std::shared_ptr<PostDownloadHandler>
   getMetalinkPostDownloadHandler();
 #endif // ENABLE_METALINK
 
 #ifdef ENABLE_BITTORRENT
-  static SharedHandle<PreDownloadHandler>
+  static std::shared_ptr<PreDownloadHandler>
   getBtPreDownloadHandler();
 
-  static SharedHandle<PostDownloadHandler>
+  static std::shared_ptr<PostDownloadHandler>
   getBtPostDownloadHandler();
 
-  static SharedHandle<PostDownloadHandler>
+  static std::shared_ptr<PostDownloadHandler>
   getUTMetadataPostDownloadHandler();
 #endif // ENABLE_BITTORRENT
 };
diff --git a/src/DownloadResult.h b/src/DownloadResult.h
index b6972ad0..729e97d2 100644
--- a/src/DownloadResult.h
+++ b/src/DownloadResult.h
@@ -41,8 +41,8 @@
 
 #include <string>
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "error_code.h"
 #include "RequestGroup.h"
 
@@ -54,9 +54,9 @@ class MetadataInfo;
 
 struct DownloadResult
 {
-  SharedHandle<GroupId> gid;
+  std::shared_ptr<GroupId> gid;
 
-  std::vector<SharedHandle<FileEntry> > fileEntries;
+  std::vector<std::shared_ptr<FileEntry> > fileEntries;
 
   bool inMemoryDownload;
 
@@ -75,9 +75,9 @@ struct DownloadResult
   // RequestGroup.cc::belongsToGID_.
   a2_gid_t belongsTo;
 
-  SharedHandle<Option> option;
+  std::shared_ptr<Option> option;
 
-  SharedHandle<MetadataInfo> metadataInfo;
+  std::shared_ptr<MetadataInfo> metadataInfo;
 
   int64_t totalLength;
 
diff --git a/src/EpollEventPoll.cc b/src/EpollEventPoll.cc
index 75408037..773310d5 100644
--- a/src/EpollEventPoll.cc
+++ b/src/EpollEventPoll.cc
@@ -168,7 +168,7 @@ int translateEvents(EventPoll::EventType events)
 bool EpollEventPoll::addEvents(sock_t socket,
                                const EpollEventPoll::KEvent& event)
 {
-  SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
+  std::shared_ptr<KSocketEntry> socketEntry(new KSocketEntry(socket));
   KSocketEntrySet::iterator i = socketEntries_.lower_bound(socketEntry);
   int r = 0;
   int errNum = 0;
@@ -220,7 +220,7 @@ bool EpollEventPoll::addEvents(sock_t socket, Command* command,
 
 #ifdef ENABLE_ASYNC_DNS
 bool EpollEventPoll::addEvents(sock_t socket, Command* command, int events,
-                               const SharedHandle<AsyncNameResolver>& rs)
+                               const std::shared_ptr<AsyncNameResolver>& rs)
 {
   return addEvents(socket, KADNSEvent(rs, command, socket, events));
 }
@@ -229,7 +229,7 @@ bool EpollEventPoll::addEvents(sock_t socket, Command* command, int events,
 bool EpollEventPoll::deleteEvents(sock_t socket,
                                   const EpollEventPoll::KEvent& event)
 {
-  SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
+  std::shared_ptr<KSocketEntry> socketEntry(new KSocketEntry(socket));
   KSocketEntrySet::iterator i = socketEntries_.find(socketEntry);
   if(i == socketEntries_.end()) {
     A2_LOG_DEBUG(fmt("Socket %d is not found in SocketEntries.", socket));
@@ -268,7 +268,7 @@ bool EpollEventPoll::deleteEvents(sock_t socket,
 
 #ifdef ENABLE_ASYNC_DNS
 bool EpollEventPoll::deleteEvents(sock_t socket, Command* command,
-                                  const SharedHandle<AsyncNameResolver>& rs)
+                                  const std::shared_ptr<AsyncNameResolver>& rs)
 {
   return deleteEvents(socket, KADNSEvent(rs, command, socket, 0));
 }
@@ -283,9 +283,9 @@ bool EpollEventPoll::deleteEvents(sock_t socket, Command* command,
 
 #ifdef ENABLE_ASYNC_DNS
 bool EpollEventPoll::addNameResolver
-(const SharedHandle<AsyncNameResolver>& resolver, Command* command)
+(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
-  SharedHandle<KAsyncNameResolverEntry> entry
+  std::shared_ptr<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   KAsyncNameResolverEntrySet::iterator itr =
     nameResolverEntries_.lower_bound(entry);
@@ -299,9 +299,9 @@ bool EpollEventPoll::addNameResolver
 }
 
 bool EpollEventPoll::deleteNameResolver
-(const SharedHandle<AsyncNameResolver>& resolver, Command* command)
+(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
-  SharedHandle<KAsyncNameResolverEntry> entry
+  std::shared_ptr<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   KAsyncNameResolverEntrySet::iterator itr =
     nameResolverEntries_.find(entry);
diff --git a/src/EpollEventPoll.h b/src/EpollEventPoll.h
index 390fd07a..4529dc01 100644
--- a/src/EpollEventPoll.h
+++ b/src/EpollEventPoll.h
@@ -70,12 +70,12 @@ private:
   friend int accumulateEvent(int events, const KEvent& event);
 
 private:
-  typedef std::set<SharedHandle<KSocketEntry>,
-                   DerefLess<SharedHandle<KSocketEntry> > > KSocketEntrySet;
+  typedef std::set<std::shared_ptr<KSocketEntry>,
+                   DerefLess<std::shared_ptr<KSocketEntry> > > KSocketEntrySet;
   KSocketEntrySet socketEntries_;
 #ifdef ENABLE_ASYNC_DNS
-  typedef std::set<SharedHandle<KAsyncNameResolverEntry>,
-                   DerefLess<SharedHandle<KAsyncNameResolverEntry> > >
+  typedef std::set<std::shared_ptr<KAsyncNameResolverEntry>,
+                   DerefLess<std::shared_ptr<KAsyncNameResolverEntry> > >
   KAsyncNameResolverEntrySet;
   KAsyncNameResolverEntrySet nameResolverEntries_;
 #endif // ENABLE_ASYNC_DNS
@@ -93,10 +93,10 @@ private:
   bool deleteEvents(sock_t socket, const KEvent& event);
 
   bool addEvents(sock_t socket, Command* command, int events,
-                 const SharedHandle<AsyncNameResolver>& rs);
+                 const std::shared_ptr<AsyncNameResolver>& rs);
 
   bool deleteEvents(sock_t socket, Command* command,
-                    const SharedHandle<AsyncNameResolver>& rs);
+                    const std::shared_ptr<AsyncNameResolver>& rs);
 
 public:
   EpollEventPoll();
@@ -114,10 +114,10 @@ public:
                             Command* command, EventPoll::EventType events);
 #ifdef ENABLE_ASYNC_DNS
 
-  virtual bool addNameResolver(const SharedHandle<AsyncNameResolver>& resolver,
+  virtual bool addNameResolver(const std::shared_ptr<AsyncNameResolver>& resolver,
                                Command* command);
   virtual bool deleteNameResolver
-  (const SharedHandle<AsyncNameResolver>& resolver, Command* command);
+  (const std::shared_ptr<AsyncNameResolver>& resolver, Command* command);
 #endif // ENABLE_ASYNC_DNS
 
   static const int IEV_READ = EPOLLIN;
diff --git a/src/Event.h b/src/Event.h
index 2cf6c0ac..249b2ce5 100644
--- a/src/Event.h
+++ b/src/Event.h
@@ -40,8 +40,8 @@
 #include <deque>
 #include <algorithm>
 #include <functional>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "a2netcompat.h"
 #include "Command.h"
 #ifdef ENABLE_ASYNC_DNS
@@ -59,10 +59,10 @@ public:
 
   virtual int getEvents() const = 0;
 
-  virtual void addSelf(const SharedHandle<SocketEntry>& socketEntry) const = 0;
+  virtual void addSelf(const std::shared_ptr<SocketEntry>& socketEntry) const = 0;
 
   virtual void removeSelf
-  (const SharedHandle<SocketEntry>& socketEntry) const = 0;
+  (const std::shared_ptr<SocketEntry>& socketEntry) const = 0;
 };
 
 template<typename SocketEntry, typename EventPoll>
@@ -124,12 +124,12 @@ public:
     }
   }
 
-  virtual void addSelf(const SharedHandle<SocketEntry>& socketEntry) const
+  virtual void addSelf(const std::shared_ptr<SocketEntry>& socketEntry) const
   {
     socketEntry->addCommandEvent(*this);
   }
 
-  virtual void removeSelf(const SharedHandle<SocketEntry>& socketEntry) const
+  virtual void removeSelf(const std::shared_ptr<SocketEntry>& socketEntry) const
   {
     socketEntry->removeCommandEvent(*this);
   }
@@ -140,12 +140,12 @@ public:
 template<typename SocketEntry, typename EventPoll>
 class ADNSEvent : public Event<SocketEntry> {
 private:
-  SharedHandle<AsyncNameResolver> resolver_;
+  std::shared_ptr<AsyncNameResolver> resolver_;
   Command* command_;
   sock_t socket_;
   int events_;
 public:
-  ADNSEvent(const SharedHandle<AsyncNameResolver>& resolver, Command* command,
+  ADNSEvent(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command,
             sock_t socket, int events):
     resolver_(resolver), command_(command), socket_(socket), events_(events) {}
 
@@ -179,12 +179,12 @@ public:
     command_->setStatusActive();
   }
 
-  virtual void addSelf(const SharedHandle<SocketEntry>& socketEntry) const
+  virtual void addSelf(const std::shared_ptr<SocketEntry>& socketEntry) const
   {
     socketEntry->addADNSEvent(*this);
   }
 
-  virtual void removeSelf(const SharedHandle<SocketEntry>& socketEntry) const
+  virtual void removeSelf(const std::shared_ptr<SocketEntry>& socketEntry) const
   {
     socketEntry->removeADNSEvent(*this);
   }
@@ -308,7 +308,7 @@ public:
 template<typename EventPoll>
 class AsyncNameResolverEntry {
 private:
-  SharedHandle<AsyncNameResolver> nameResolver_;
+  std::shared_ptr<AsyncNameResolver> nameResolver_;
 
   Command* command_;
 
@@ -317,7 +317,7 @@ private:
   sock_t sockets_[ARES_GETSOCK_MAXNUM];
 
 public:
-  AsyncNameResolverEntry(const SharedHandle<AsyncNameResolver>& nameResolver,
+  AsyncNameResolverEntry(const std::shared_ptr<AsyncNameResolver>& nameResolver,
                          Command* command):
     nameResolver_(nameResolver), command_(command), socketsSize_(0) {}
 
diff --git a/src/EventPoll.h b/src/EventPoll.h
index 7217ef25..9d02d9b9 100644
--- a/src/EventPoll.h
+++ b/src/EventPoll.h
@@ -36,7 +36,9 @@
 #define D_EVENT_POLL_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "a2time.h"
 #include "a2netcompat.h"
 
@@ -66,10 +68,10 @@ public:
                             EventType events) = 0;
 #ifdef ENABLE_ASYNC_DNS
 
-  virtual bool addNameResolver(const SharedHandle<AsyncNameResolver>& resolver,
+  virtual bool addNameResolver(const std::shared_ptr<AsyncNameResolver>& resolver,
                                Command* command) = 0;
   virtual bool deleteNameResolver
-  (const SharedHandle<AsyncNameResolver>& resolver, Command* command) = 0;
+  (const std::shared_ptr<AsyncNameResolver>& resolver, Command* command) = 0;
 #endif // ENABLE_ASYNC_DNS
 
 };
diff --git a/src/Exception.cc b/src/Exception.cc
index 1492b59b..8fa7c0bc 100644
--- a/src/Exception.cc
+++ b/src/Exception.cc
@@ -124,7 +124,7 @@ std::string Exception::stackTrace() const
   }
   s << "errorCode=" << errorCode_ << " ";
   s  << what() << "\n";
-  SharedHandle<Exception> e = cause_;
+  std::shared_ptr<Exception> e = cause_;
   while(e) {
     s << "  -> " << "[" << e->file_ << ":" << e->line_ << "] ";
     if(e->getErrNum()) {
diff --git a/src/Exception.h b/src/Exception.h
index e8fb76cb..e7a7ace6 100644
--- a/src/Exception.h
+++ b/src/Exception.h
@@ -38,8 +38,8 @@
 #include "common.h"
 
 #include <string>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "error_code.h"
 
 namespace aria2 {
@@ -57,9 +57,9 @@ private:
   error_code::Value errorCode_;
   // Exception that this object wraps. Normally this cause_ is the
   // root cause of this exception.
-  SharedHandle<Exception> cause_;
+  std::shared_ptr<Exception> cause_;
 protected:
-  virtual SharedHandle<Exception> copy() const = 0;
+  virtual std::shared_ptr<Exception> copy() const = 0;
 
 public:
   Exception(const char* file, int line, const std::string& msg);
diff --git a/src/ExtensionMessageFactory.h b/src/ExtensionMessageFactory.h
index 9a49d9d0..6cde2041 100644
--- a/src/ExtensionMessageFactory.h
+++ b/src/ExtensionMessageFactory.h
@@ -36,7 +36,8 @@
 #define D_EXTENSION_MESSAGE_FACTORY_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -46,7 +47,7 @@ class ExtensionMessageFactory {
 public:
   virtual ~ExtensionMessageFactory() {}
 
-  virtual SharedHandle<ExtensionMessage>
+  virtual std::shared_ptr<ExtensionMessage>
   createMessage(const unsigned char* data, size_t length) = 0;
 };
 
diff --git a/src/FatalException.cc b/src/FatalException.cc
index e8b19687..7d545599 100644
--- a/src/FatalException.cc
+++ b/src/FatalException.cc
@@ -36,9 +36,9 @@
 
 namespace aria2 {
 
-SharedHandle<Exception> FatalException::copy() const
+std::shared_ptr<Exception> FatalException::copy() const
 {
-  SharedHandle<Exception> e(new FatalException(*this));
+  std::shared_ptr<Exception> e(new FatalException(*this));
   return e;
 }
 
diff --git a/src/FatalException.h b/src/FatalException.h
index 852ae613..8b777a25 100644
--- a/src/FatalException.h
+++ b/src/FatalException.h
@@ -40,7 +40,7 @@ namespace aria2 {
 
 class FatalException:public Exception {
 protected:
-  virtual SharedHandle<Exception> copy() const;
+  virtual std::shared_ptr<Exception> copy() const;
 public:
   FatalException(const char* file, int line, const std::string& msg);
 
diff --git a/src/FeatureConfig.cc b/src/FeatureConfig.cc
index c78043f5..a61c9283 100644
--- a/src/FeatureConfig.cc
+++ b/src/FeatureConfig.cc
@@ -173,23 +173,23 @@ std::string usedLibs()
 {
   std::string res;
 #ifdef HAVE_ZLIB
-  res += "zlib/"ZLIB_VERSION" ";
+  res += "zlib/" ZLIB_VERSION " ";
 #endif // HAVE_ZLIB
 #ifdef HAVE_LIBXML2
-  res += "libxml2/"LIBXML_DOTTED_VERSION" ";
+  res += "libxml2/" LIBXML_DOTTED_VERSION " ";
 #endif // HAVE_LIBXML2
 #ifdef HAVE_LIBEXPAT
   res += fmt("expat/%d.%d.%d ",
              XML_MAJOR_VERSION, XML_MINOR_VERSION, XML_MICRO_VERSION);
 #endif // HAVE_LIBEXPAT
 #ifdef HAVE_SQLITE3
-  res += "sqlite3/"SQLITE_VERSION" ";
+  res += "sqlite3/" SQLITE_VERSION " ";
 #endif // HAVE_SQLITE3
 #ifdef HAVE_APPLETLS
   res += "appleTLS ";
 #endif // HAVE_APPLETLS
 #ifdef HAVE_LIBGNUTLS
-  res += "GnuTLS/"GNUTLS_VERSION" ";
+  res += "GnuTLS/" GNUTLS_VERSION " ";
 #endif // HAVE_LIBGNUTLS
 #ifdef HAVE_OPENSSL
   res += fmt("OpenSSL/%ld.%ld.%ld",
@@ -211,10 +211,10 @@ std::string usedLibs()
              __GNU_MP_VERSION_PATCHLEVEL);
 #endif // HAVE_LIBGMP
 #ifdef HAVE_LIBGCRYPT
-  res += "libgcrypt/"GCRYPT_VERSION" ";
+  res += "libgcrypt/" GCRYPT_VERSION " ";
 #endif // HAVE_LIBGCRYPT
 #ifdef HAVE_LIBCARES
-  res += "c-ares/"ARES_VERSION_STR" ";
+  res += "c-ares/" ARES_VERSION_STR " ";
 #endif // HAVE_LIBCARES
   if(!res.empty()) {
     res.erase(res.length()-1);
diff --git a/src/FeedbackURISelector.cc b/src/FeedbackURISelector.cc
index 7e2f6563..903abd0b 100644
--- a/src/FeedbackURISelector.cc
+++ b/src/FeedbackURISelector.cc
@@ -50,7 +50,7 @@
 namespace aria2 {
 
 FeedbackURISelector::FeedbackURISelector
-(const SharedHandle<ServerStatMan>& serverStatMan)
+(const std::shared_ptr<ServerStatMan>& serverStatMan)
   : serverStatMan_(serverStatMan)
 {}
 
@@ -100,7 +100,7 @@ std::string FeedbackURISelector::selectRarer
     }
     std::string host = uri::getFieldString(us, USR_HOST, (*i).c_str());
     std::string protocol = uri::getFieldString(us, USR_SCHEME, (*i).c_str());
-    SharedHandle<ServerStat> ss = serverStatMan_->find(host, protocol);
+    std::shared_ptr<ServerStat> ss = serverStatMan_->find(host, protocol);
     if(ss && ss->isError()) {
       A2_LOG_DEBUG(fmt("Error not considered: %s", (*i).c_str()));
       continue;
@@ -128,7 +128,7 @@ std::string FeedbackURISelector::selectFaster
   const size_t NUM_URI = 10;
   // Ignore low speed server
   const int SPEED_THRESHOLD = 20*1024;
-  std::vector<std::pair<SharedHandle<ServerStat>, std::string> > fastCands;
+  std::vector<std::pair<std::shared_ptr<ServerStat>, std::string> > fastCands;
   std::vector<std::string> normCands;
   for(std::deque<std::string>::const_iterator i = uris.begin(),
         eoi = uris.end(); i != eoi && fastCands.size() < NUM_URI; ++i) {
@@ -143,7 +143,7 @@ std::string FeedbackURISelector::selectFaster
       continue;
     }
     std::string protocol = uri::getFieldString(us, USR_SCHEME, (*i).c_str());
-    SharedHandle<ServerStat> ss = serverStatMan_->find(host, protocol);
+    std::shared_ptr<ServerStat> ss = serverStatMan_->find(host, protocol);
     if(!ss) {
       normCands.push_back(*i);
     } else if(ss->isOK()) {
diff --git a/src/FeedbackURISelector.h b/src/FeedbackURISelector.h
index 6f5ced64..dedc8f1d 100644
--- a/src/FeedbackURISelector.h
+++ b/src/FeedbackURISelector.h
@@ -35,7 +35,8 @@
 #ifndef D_FEEDBACK_URI_SELECTOR_H
 #define D_FEEDBACK_URI_SELECTOR_H
 #include "URISelector.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -43,7 +44,7 @@ class ServerStatMan;
 
 class FeedbackURISelector:public URISelector {
 private:
-  SharedHandle<ServerStatMan> serverStatMan_;
+  std::shared_ptr<ServerStatMan> serverStatMan_;
 
   std::string selectRarer
   (const std::deque<std::string>& uris,
@@ -53,7 +54,7 @@ private:
   (const std::deque<std::string>& uris,
    const std::vector<std::pair<size_t, std::string> >& usedHosts);
 public:
-  FeedbackURISelector(const SharedHandle<ServerStatMan>& serverStatMan);
+  FeedbackURISelector(const std::shared_ptr<ServerStatMan>& serverStatMan);
 
   virtual ~FeedbackURISelector();
 
diff --git a/src/FileAllocationCommand.cc b/src/FileAllocationCommand.cc
index 5486503a..54c4e7a5 100644
--- a/src/FileAllocationCommand.cc
+++ b/src/FileAllocationCommand.cc
@@ -54,7 +54,7 @@ namespace aria2 {
 
 FileAllocationCommand::FileAllocationCommand
 (cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e,
- const SharedHandle<FileAllocationEntry>& fileAllocationEntry):
+ const std::shared_ptr<FileAllocationEntry>& fileAllocationEntry):
   RealtimeCommand(cuid, requestGroup, e),
   fileAllocationEntry_(fileAllocationEntry) {}
 
diff --git a/src/FileAllocationCommand.h b/src/FileAllocationCommand.h
index ef38b5a2..cad28e4c 100644
--- a/src/FileAllocationCommand.h
+++ b/src/FileAllocationCommand.h
@@ -36,7 +36,9 @@
 #define D_FILE_ALLOCATION_COMMAND_H
 
 #include "RealtimeCommand.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "TimerA2.h"
 
 namespace aria2 {
@@ -45,12 +47,12 @@ class FileAllocationEntry;
 
 class FileAllocationCommand : public RealtimeCommand {
 private:
-  SharedHandle<FileAllocationEntry> fileAllocationEntry_;
+  std::shared_ptr<FileAllocationEntry> fileAllocationEntry_;
   Timer timer_;
 public:
   FileAllocationCommand(cuid_t cuid, RequestGroup* requestGroup,
                         DownloadEngine* e,
-                        const SharedHandle<FileAllocationEntry>& fileAllocationEntry);
+                        const std::shared_ptr<FileAllocationEntry>& fileAllocationEntry);
 
   virtual ~FileAllocationCommand();
 
diff --git a/src/FileAllocationDispatcherCommand.cc b/src/FileAllocationDispatcherCommand.cc
index 00c282e9..70e6573a 100644
--- a/src/FileAllocationDispatcherCommand.cc
+++ b/src/FileAllocationDispatcherCommand.cc
@@ -45,13 +45,13 @@ namespace aria2 {
 
 FileAllocationDispatcherCommand::FileAllocationDispatcherCommand
 (cuid_t cuid,
- const SharedHandle<FileAllocationMan>& fileAllocMan,
+ const std::shared_ptr<FileAllocationMan>& fileAllocMan,
  DownloadEngine* e)
   : SequentialDispatcherCommand<FileAllocationEntry>(cuid, fileAllocMan, e)
 {}
 
 Command* FileAllocationDispatcherCommand::createCommand
-(const SharedHandle<FileAllocationEntry>& entry)
+(const std::shared_ptr<FileAllocationEntry>& entry)
 {
   cuid_t newCUID = getDownloadEngine()->newCUID();
   A2_LOG_INFO(fmt(MSG_FILE_ALLOCATION_DISPATCH, newCUID));
diff --git a/src/FileAllocationDispatcherCommand.h b/src/FileAllocationDispatcherCommand.h
index 88c03af6..f41fb1b7 100644
--- a/src/FileAllocationDispatcherCommand.h
+++ b/src/FileAllocationDispatcherCommand.h
@@ -47,11 +47,11 @@ class FileAllocationDispatcherCommand :
 public:
   FileAllocationDispatcherCommand
   (cuid_t cuid,
-   const SharedHandle<FileAllocationMan>& fileAllocMan,
+   const std::shared_ptr<FileAllocationMan>& fileAllocMan,
    DownloadEngine* e);
 protected:
   virtual Command* createCommand
-  (const SharedHandle<FileAllocationEntry>& entry);
+  (const std::shared_ptr<FileAllocationEntry>& entry);
 };
 
 } // namespace aria2
diff --git a/src/FileAllocationEntry.h b/src/FileAllocationEntry.h
index 26228413..74a455d5 100644
--- a/src/FileAllocationEntry.h
+++ b/src/FileAllocationEntry.h
@@ -38,8 +38,8 @@
 #include "RequestGroupEntry.h"
 
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "ProgressAwareEntry.h"
 
 namespace aria2 {
@@ -50,7 +50,7 @@ class DownloadEngine;
 
 class FileAllocationEntry : public RequestGroupEntry, public ProgressAwareEntry {
 private:
-  SharedHandle<FileAllocationIterator> fileAllocationIterator_;
+  std::shared_ptr<FileAllocationIterator> fileAllocationIterator_;
 public:
   FileAllocationEntry(RequestGroup* requestGroup, Command* nextCommand = 0);
 
diff --git a/src/FileAllocationIterator.h b/src/FileAllocationIterator.h
index f2b8b2c8..86562c24 100644
--- a/src/FileAllocationIterator.h
+++ b/src/FileAllocationIterator.h
@@ -36,7 +36,7 @@
 #define D_FILE_ALLOCATION_ITERATOR_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
 #include <unistd.h>
 
 namespace aria2 {
diff --git a/src/FileEntry.cc b/src/FileEntry.cc
index edf0a36e..e3be45eb 100644
--- a/src/FileEntry.cc
+++ b/src/FileEntry.cc
@@ -52,8 +52,8 @@
 namespace aria2 {
 
 bool FileEntry::RequestFaster::operator()
-  (const SharedHandle<Request>& lhs,
-   const SharedHandle<Request>& rhs) const
+  (const std::shared_ptr<Request>& lhs,
+   const std::shared_ptr<Request>& rhs) const
 {
   if(!lhs->getPeerStat()) {
     return false;
@@ -139,15 +139,15 @@ OutputIterator enumerateInFlightHosts
 }
 } // namespace
 
-SharedHandle<Request>
+std::shared_ptr<Request>
 FileEntry::getRequest
-(const SharedHandle<URISelector>& selector,
+(const std::shared_ptr<URISelector>& selector,
  bool uriReuse,
  const std::vector<std::pair<size_t, std::string> >& usedHosts,
  const std::string& referer,
  const std::string& method)
 {
-  SharedHandle<Request> req;
+  std::shared_ptr<Request> req;
   if(requestPool_.empty()) {
     std::vector<std::string> inFlightHosts;
     enumerateInFlightHosts(inFlightRequests_.begin(), inFlightRequests_.end(),
@@ -215,54 +215,54 @@ FileEntry::getRequest
   return req;
 }
 
-SharedHandle<Request>
-FileEntry::findFasterRequest(const SharedHandle<Request>& base)
+std::shared_ptr<Request>
+FileEntry::findFasterRequest(const std::shared_ptr<Request>& base)
 {
   const int startupIdleTime = 10;
   if(requestPool_.empty() ||
      lastFasterReplace_.difference(global::wallclock()) < startupIdleTime) {
-    return SharedHandle<Request>();
+    return std::shared_ptr<Request>();
   }
-  const SharedHandle<PeerStat>& fastest =
+  const std::shared_ptr<PeerStat>& fastest =
     (*requestPool_.begin())->getPeerStat();
   if(!fastest) {
-    return SharedHandle<Request>();
+    return std::shared_ptr<Request>();
   }
-  const SharedHandle<PeerStat>& basestat = base->getPeerStat();
+  const std::shared_ptr<PeerStat>& basestat = base->getPeerStat();
   // TODO hard coded value. See PREF_STARTUP_IDLE_TIME
   if(!basestat ||
      (basestat->getDownloadStartTime().
       difference(global::wallclock()) >= startupIdleTime &&
       fastest->getAvgDownloadSpeed()*0.8 > basestat->calculateDownloadSpeed())){
     // TODO we should consider that "fastest" is very slow.
-    SharedHandle<Request> fastestRequest = *requestPool_.begin();
+    std::shared_ptr<Request> fastestRequest = *requestPool_.begin();
     requestPool_.erase(requestPool_.begin());
     inFlightRequests_.insert(fastestRequest);
     lastFasterReplace_ = global::wallclock();
     return fastestRequest;
   }
-  return SharedHandle<Request>();
+  return std::shared_ptr<Request>();
 }
 
-SharedHandle<Request>
+std::shared_ptr<Request>
 FileEntry::findFasterRequest
-(const SharedHandle<Request>& base,
+(const std::shared_ptr<Request>& base,
  const std::vector<std::pair<size_t, std::string> >& usedHosts,
- const SharedHandle<ServerStatMan>& serverStatMan)
+ const std::shared_ptr<ServerStatMan>& serverStatMan)
 {
   const int startupIdleTime = 10;
   const int SPEED_THRESHOLD = 20*1024;
   if(lastFasterReplace_.difference(global::wallclock()) < startupIdleTime) {
-    return SharedHandle<Request>();
+    return std::shared_ptr<Request>();
   }
   std::vector<std::string> inFlightHosts;
   enumerateInFlightHosts(inFlightRequests_.begin(), inFlightRequests_.end(),
                          std::back_inserter(inFlightHosts));
-  const SharedHandle<PeerStat>& basestat = base->getPeerStat();
+  const std::shared_ptr<PeerStat>& basestat = base->getPeerStat();
   A2_LOG_DEBUG("Search faster server using ServerStat.");
   // Use first 10 good URIs to introduce some randomness.
   const size_t NUM_URI = 10;
-  std::vector<std::pair<SharedHandle<ServerStat>, std::string> > fastCands;
+  std::vector<std::pair<std::shared_ptr<ServerStat>, std::string> > fastCands;
   std::vector<std::string> normCands;
   for(std::deque<std::string>::const_iterator i = uris_.begin(),
         eoi = uris_.end(); i != eoi && fastCands.size() < NUM_URI; ++i) {
@@ -284,7 +284,7 @@ FileEntry::findFasterRequest
       A2_LOG_DEBUG(fmt("%s is in usedHosts, not considered", (*i).c_str()));
       continue;
     }
-    SharedHandle<ServerStat> ss = serverStatMan->find(host, protocol);
+    std::shared_ptr<ServerStat> ss = serverStatMan->find(host, protocol);
     if(ss && ss->isOK()) {
       if((basestat &&
           ss->getDownloadSpeed() > basestat->calculateDownloadSpeed()*1.5) ||
@@ -295,7 +295,7 @@ FileEntry::findFasterRequest
   }
   if(!fastCands.empty()) {
     std::sort(fastCands.begin(), fastCands.end(), ServerStatFaster());
-    SharedHandle<Request> fastestRequest(new Request());
+    std::shared_ptr<Request> fastestRequest(new Request());
     const std::string& uri = fastCands.front().second;
     A2_LOG_DEBUG(fmt("Selected %s from fastCands", uri.c_str()));
     fastestRequest->setUri(uri);
@@ -307,12 +307,12 @@ FileEntry::findFasterRequest
     return fastestRequest;
   }
   A2_LOG_DEBUG("No faster server found.");
-  return SharedHandle<Request>();
+  return std::shared_ptr<Request>();
 }
 
-void FileEntry::storePool(const SharedHandle<Request>& request)
+void FileEntry::storePool(const std::shared_ptr<Request>& request)
 {
-  const SharedHandle<PeerStat>& peerStat = request->getPeerStat();
+  const std::shared_ptr<PeerStat>& peerStat = request->getPeerStat();
   if(peerStat) {
     // We need to calculate average download speed here in order to
     // store Request in the right position in the pool.
@@ -321,7 +321,7 @@ void FileEntry::storePool(const SharedHandle<Request>& request)
   requestPool_.insert(request);
 }
 
-void FileEntry::poolRequest(const SharedHandle<Request>& request)
+void FileEntry::poolRequest(const std::shared_ptr<Request>& request)
 {
   removeRequest(request);
   if(!request->removalRequested()) {
@@ -329,7 +329,7 @@ void FileEntry::poolRequest(const SharedHandle<Request>& request)
   }
 }
 
-bool FileEntry::removeRequest(const SharedHandle<Request>& request)
+bool FileEntry::removeRequest(const std::shared_ptr<Request>& request)
 {
   return inFlightRequests_.erase(request) == 1;
 }
@@ -497,7 +497,7 @@ bool FileEntry::removeUri(const std::string& uri)
     }
   } else {
     spentUris_.erase(itr);
-    SharedHandle<Request> req;
+    std::shared_ptr<Request> req;
     InFlightRequestSet::iterator riter =
       findRequestByUri(inFlightRequests_.begin(), inFlightRequests_.end(), uri);
     if(riter == inFlightRequests_.end()) {
@@ -588,7 +588,7 @@ bool FileEntry::emptyRequestUri() const
 
 void writeFilePath
 (std::ostream& o,
- const SharedHandle<FileEntry>& entry,
+ const std::shared_ptr<FileEntry>& entry,
  bool memory)
 {
   if(entry->getPath().empty()) {
diff --git a/src/FileEntry.h b/src/FileEntry.h
index 9ba57f00..765d3104 100644
--- a/src/FileEntry.h
+++ b/src/FileEntry.h
@@ -42,8 +42,8 @@
 #include <vector>
 #include <ostream>
 #include <set>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "File.h"
 #include "Request.h"
 #include "URIResult.h"
@@ -60,7 +60,7 @@ class ServerStatMan;
 
 class FileEntry {
 public:
-  typedef std::set<SharedHandle<Request>, RefLess<Request> >
+  typedef std::set<std::shared_ptr<Request>, RefLess<Request> >
   InFlightRequestSet;
 private:
   std::string path_;
@@ -72,11 +72,11 @@ private:
 
   class RequestFaster {
   public:
-    bool operator()(const SharedHandle<Request>& lhs,
-                    const SharedHandle<Request>& rhs) const;
+    bool operator()(const std::shared_ptr<Request>& lhs,
+                    const std::shared_ptr<Request>& rhs) const;
   };
 
-  typedef std::set<SharedHandle<Request>, RequestFaster> RequestPool;
+  typedef std::set<std::shared_ptr<Request>, RequestFaster> RequestPool;
   RequestPool requestPool_;
   InFlightRequestSet inFlightRequests_;
   std::string contentType_;
@@ -88,7 +88,7 @@ private:
   std::string originalName_;
   Timer lastFasterReplace_;
 
-  void storePool(const SharedHandle<Request>& request);
+  void storePool(const std::shared_ptr<Request>& request);
 public:
   FileEntry();
 
@@ -178,8 +178,8 @@ public:
   // returns Request object either because uris_ is empty or all URI
   // are not be usable because maxConnectionPerServer_ limit, then
   // reuse used URIs and do selection again.
-  SharedHandle<Request> getRequest
-  (const SharedHandle<URISelector>& selector,
+  std::shared_ptr<Request> getRequest
+  (const std::shared_ptr<URISelector>& selector,
    bool uriReuse,
    const std::vector<std::pair<size_t, std::string> >& usedHosts,
    const std::string& referer = A2STR::NIL,
@@ -188,18 +188,18 @@ public:
   // Finds pooled Request object which is faster than passed one,
   // comparing their PeerStat objects. If such Request is found, it is
   // removed from the pool and returned.
-  SharedHandle<Request> findFasterRequest(const SharedHandle<Request>& base);
+  std::shared_ptr<Request> findFasterRequest(const std::shared_ptr<Request>& base);
 
   // Finds faster server using ServerStatMan.
-  SharedHandle<Request>
+  std::shared_ptr<Request>
   findFasterRequest
-  (const SharedHandle<Request>& base,
+  (const std::shared_ptr<Request>& base,
    const std::vector<std::pair<size_t, std::string> >& usedHosts,
-   const SharedHandle<ServerStatMan>& serverStatMan);
+   const std::shared_ptr<ServerStatMan>& serverStatMan);
 
-  void poolRequest(const SharedHandle<Request>& request);
+  void poolRequest(const std::shared_ptr<Request>& request);
 
-  bool removeRequest(const SharedHandle<Request>& request);
+  bool removeRequest(const std::shared_ptr<Request>& request);
 
   size_t countInFlightRequest() const;
 
@@ -277,9 +277,9 @@ public:
 
 // Returns the first FileEntry which isRequested() method returns
 // true.  If no such FileEntry exists, then returns
-// SharedHandle<FileEntry>().
+// std::shared_ptr<FileEntry>().
 template<typename InputIterator>
-SharedHandle<FileEntry> getFirstRequestedFileEntry
+std::shared_ptr<FileEntry> getFirstRequestedFileEntry
 (InputIterator first, InputIterator last)
 {
   for(; first != last; ++first) {
@@ -287,7 +287,7 @@ SharedHandle<FileEntry> getFirstRequestedFileEntry
       return *first;
     }
   }
-  return SharedHandle<FileEntry>();
+  return std::shared_ptr<FileEntry>();
 }
 
 // Counts the number of files selected in the given iterator range
@@ -321,7 +321,7 @@ bool isUriSuppliedForRequsetFileEntry(InputIterator first, InputIterator last)
 // FileEntry, writes "n/a" to o.
 void writeFilePath
 (std::ostream& o,
- const SharedHandle<FileEntry>& entry,
+ const std::shared_ptr<FileEntry>& entry,
  bool memory);
 
 // Writes first filename to given o.  If memory is true, the output is
@@ -333,7 +333,7 @@ template<typename InputIterator>
 void writeFilePath
 (InputIterator first, InputIterator last, std::ostream& o, bool memory)
 {
-  SharedHandle<FileEntry> e = getFirstRequestedFileEntry(first, last);
+  std::shared_ptr<FileEntry> e = getFirstRequestedFileEntry(first, last);
   if(!e) {
     o << "n/a";
   } else {
diff --git a/src/FillRequestGroupCommand.cc b/src/FillRequestGroupCommand.cc
index 414402f5..ddfbb8b6 100644
--- a/src/FillRequestGroupCommand.cc
+++ b/src/FillRequestGroupCommand.cc
@@ -60,7 +60,7 @@ bool FillRequestGroupCommand::execute()
   if(e_->isHaltRequested()) {
     return true;
   }
-  const SharedHandle<RequestGroupMan>& rgman = e_->getRequestGroupMan();
+  const std::shared_ptr<RequestGroupMan>& rgman = e_->getRequestGroupMan();
   if(rgman->queueCheckRequested()) {
     while(rgman->queueCheckRequested()) {
       try {
diff --git a/src/FillRequestGroupCommand.h b/src/FillRequestGroupCommand.h
index 1702d514..dba0801d 100644
--- a/src/FillRequestGroupCommand.h
+++ b/src/FillRequestGroupCommand.h
@@ -36,7 +36,6 @@
 #define D_FILL_REQUEST_GROUP_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
 #include "a2time.h"
 
 namespace aria2 {
diff --git a/src/FtpConnection.cc b/src/FtpConnection.cc
index d05872cf..7e773cd2 100644
--- a/src/FtpConnection.cc
+++ b/src/FtpConnection.cc
@@ -62,9 +62,9 @@ namespace aria2 {
 
 FtpConnection::FtpConnection
 (cuid_t cuid,
- const SharedHandle<SocketCore>& socket,
- const SharedHandle<Request>& req,
- const SharedHandle<AuthConfig>& authConfig,
+ const std::shared_ptr<SocketCore>& socket,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<AuthConfig>& authConfig,
  const Option* op)
   : cuid_(cuid),
     socket_(socket),
@@ -199,17 +199,17 @@ bool FtpConnection::sendPasv()
   return socketBuffer_.sendBufferIsEmpty();
 }
 
-SharedHandle<SocketCore> FtpConnection::createServerSocket()
+std::shared_ptr<SocketCore> FtpConnection::createServerSocket()
 {
   std::pair<std::string, uint16_t> addrinfo;
   socket_->getAddrInfo(addrinfo);
-  SharedHandle<SocketCore> serverSocket(new SocketCore());
+  std::shared_ptr<SocketCore> serverSocket(new SocketCore());
   serverSocket->bind(addrinfo.first.c_str(), 0, AF_UNSPEC);
   serverSocket->beginListen();
   return serverSocket;
 }
 
-bool FtpConnection::sendEprt(const SharedHandle<SocketCore>& serverSocket)
+bool FtpConnection::sendEprt(const std::shared_ptr<SocketCore>& serverSocket)
 {
   if(socketBuffer_.sendBufferIsEmpty()) {
     sockaddr_union sockaddr;
@@ -229,7 +229,7 @@ bool FtpConnection::sendEprt(const SharedHandle<SocketCore>& serverSocket)
   return socketBuffer_.sendBufferIsEmpty();
 }
 
-bool FtpConnection::sendPort(const SharedHandle<SocketCore>& serverSocket)
+bool FtpConnection::sendPort(const std::shared_ptr<SocketCore>& serverSocket)
 {
   if(socketBuffer_.sendBufferIsEmpty()) {
     std::pair<std::string, uint16_t> addrinfo;
@@ -249,7 +249,7 @@ bool FtpConnection::sendPort(const SharedHandle<SocketCore>& serverSocket)
   return socketBuffer_.sendBufferIsEmpty();
 }
 
-bool FtpConnection::sendRest(const SharedHandle<Segment>& segment)
+bool FtpConnection::sendRest(const std::shared_ptr<Segment>& segment)
 {
   if(socketBuffer_.sendBufferIsEmpty()) {
     std::string request =
diff --git a/src/FtpConnection.h b/src/FtpConnection.h
index b6d3f12f..b751f50c 100644
--- a/src/FtpConnection.h
+++ b/src/FtpConnection.h
@@ -39,8 +39,8 @@
 
 #include <utility>
 #include <string>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimeA2.h"
 #include "SocketBuffer.h"
 #include "Command.h"
@@ -56,10 +56,10 @@ class AuthConfig;
 class FtpConnection {
 private:
   cuid_t cuid_;
-  SharedHandle<SocketCore> socket_;
-  SharedHandle<Request> req_;
+  std::shared_ptr<SocketCore> socket_;
+  std::shared_ptr<Request> req_;
 
-  SharedHandle<AuthConfig> authConfig_;
+  std::shared_ptr<AuthConfig> authConfig_;
 
   const Option* option_;
 
@@ -77,9 +77,9 @@ private:
   //prepare for large banners
   static const size_t MAX_RECV_BUFFER = 65536;
 public:
-  FtpConnection(cuid_t cuid, const SharedHandle<SocketCore>& socket,
-                const SharedHandle<Request>& req,
-                const SharedHandle<AuthConfig>& authConfig,
+  FtpConnection(cuid_t cuid, const std::shared_ptr<SocketCore>& socket,
+                const std::shared_ptr<Request>& req,
+                const std::shared_ptr<AuthConfig>& authConfig,
                 const Option* op);
   ~FtpConnection();
   bool sendUser();
@@ -91,10 +91,10 @@ public:
   bool sendSize();
   bool sendEpsv();
   bool sendPasv();
-  SharedHandle<SocketCore> createServerSocket();
-  bool sendEprt(const SharedHandle<SocketCore>& serverSocket);
-  bool sendPort(const SharedHandle<SocketCore>& serverSocket);
-  bool sendRest(const SharedHandle<Segment>& segment);
+  std::shared_ptr<SocketCore> createServerSocket();
+  bool sendEprt(const std::shared_ptr<SocketCore>& serverSocket);
+  bool sendPort(const std::shared_ptr<SocketCore>& serverSocket);
+  bool sendRest(const std::shared_ptr<Segment>& segment);
   bool sendRetr();
 
   int receiveResponse();
diff --git a/src/FtpDownloadCommand.cc b/src/FtpDownloadCommand.cc
index 84e6bc58..81f55541 100644
--- a/src/FtpDownloadCommand.cc
+++ b/src/FtpDownloadCommand.cc
@@ -50,15 +50,15 @@ namespace aria2 {
 
 FtpDownloadCommand::FtpDownloadCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
- const SharedHandle<FtpConnection>& ftpConnection,
+ const std::shared_ptr<FtpConnection>& ftpConnection,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& dataSocket,
- const SharedHandle<SocketCore>& ctrlSocket)
+ const std::shared_ptr<SocketCore>& dataSocket,
+ const std::shared_ptr<SocketCore>& ctrlSocket)
   :DownloadCommand(cuid, req, fileEntry, requestGroup, e, dataSocket,
-                   SharedHandle<SocketRecvBuffer>
+                   std::shared_ptr<SocketRecvBuffer>
                    (new SocketRecvBuffer(dataSocket))),
    ftpConnection_(ftpConnection),
    ctrlSocket_(ctrlSocket) {}
diff --git a/src/FtpDownloadCommand.h b/src/FtpDownloadCommand.h
index 24eeabe8..77b41172 100644
--- a/src/FtpDownloadCommand.h
+++ b/src/FtpDownloadCommand.h
@@ -43,21 +43,21 @@ class FtpConnection;
 
 class FtpDownloadCommand : public DownloadCommand {
 private:
-  SharedHandle<FtpConnection> ftpConnection_;
+  std::shared_ptr<FtpConnection> ftpConnection_;
 
-  SharedHandle<SocketCore> ctrlSocket_;
+  std::shared_ptr<SocketCore> ctrlSocket_;
 protected:
   virtual bool prepareForNextSegment();
   virtual int64_t getRequestEndOffset() const;
 public:
   FtpDownloadCommand(cuid_t cuid,
-                     const SharedHandle<Request>& req,
-                     const SharedHandle<FileEntry>& fileEntry,
+                     const std::shared_ptr<Request>& req,
+                     const std::shared_ptr<FileEntry>& fileEntry,
                      RequestGroup* requestGroup,
-                     const SharedHandle<FtpConnection>& ftpConnection,
+                     const std::shared_ptr<FtpConnection>& ftpConnection,
                      DownloadEngine* e,
-                     const SharedHandle<SocketCore>& dataSocket,
-                     const SharedHandle<SocketCore>& ctrlSocket);
+                     const std::shared_ptr<SocketCore>& dataSocket,
+                     const std::shared_ptr<SocketCore>& ctrlSocket);
   virtual ~FtpDownloadCommand();
 };
 
diff --git a/src/FtpFinishDownloadCommand.cc b/src/FtpFinishDownloadCommand.cc
index 1af8fdce..3002f631 100644
--- a/src/FtpFinishDownloadCommand.cc
+++ b/src/FtpFinishDownloadCommand.cc
@@ -56,12 +56,12 @@ namespace aria2 {
 
 FtpFinishDownloadCommand::FtpFinishDownloadCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
- const SharedHandle<FtpConnection>& ftpConnection,
+ const std::shared_ptr<FtpConnection>& ftpConnection,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& socket)
+ const std::shared_ptr<SocketCore>& socket)
   :AbstractCommand(cuid, req, fileEntry, requestGroup, e, socket),
    ftpConnection_(ftpConnection)
 {}
diff --git a/src/FtpFinishDownloadCommand.h b/src/FtpFinishDownloadCommand.h
index fc9e24f3..fb3f1be2 100644
--- a/src/FtpFinishDownloadCommand.h
+++ b/src/FtpFinishDownloadCommand.h
@@ -43,19 +43,19 @@ class FtpConnection;
 
 class FtpFinishDownloadCommand : public AbstractCommand {
 private:
-  SharedHandle<FtpConnection> ftpConnection_;
+  std::shared_ptr<FtpConnection> ftpConnection_;
 protected:
   virtual bool execute();
 
   virtual bool executeInternal();
 public:
   FtpFinishDownloadCommand(cuid_t cuid,
-                           const SharedHandle<Request>& req,
-                           const SharedHandle<FileEntry>& fileEntry,
+                           const std::shared_ptr<Request>& req,
+                           const std::shared_ptr<FileEntry>& fileEntry,
                            RequestGroup* requestGroup,
-                           const SharedHandle<FtpConnection>& ftpConnection,
+                           const std::shared_ptr<FtpConnection>& ftpConnection,
                            DownloadEngine* e,
-                           const SharedHandle<SocketCore>& socket);
+                           const std::shared_ptr<SocketCore>& socket);
   virtual ~FtpFinishDownloadCommand();
 };
 
diff --git a/src/FtpInitiateConnectionCommand.cc b/src/FtpInitiateConnectionCommand.cc
index 80ebfb82..9b026a89 100644
--- a/src/FtpInitiateConnectionCommand.cc
+++ b/src/FtpInitiateConnectionCommand.cc
@@ -65,8 +65,8 @@ namespace aria2 {
 
 FtpInitiateConnectionCommand::FtpInitiateConnectionCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e)
   :InitiateConnectionCommand(cuid, req, fileEntry, requestGroup, e) {}
@@ -76,12 +76,12 @@ FtpInitiateConnectionCommand::~FtpInitiateConnectionCommand() {}
 Command* FtpInitiateConnectionCommand::createNextCommand
 (const std::string& hostname, const std::string& addr, uint16_t port,
  const std::vector<std::string>& resolvedAddresses,
- const SharedHandle<Request>& proxyRequest)
+ const std::shared_ptr<Request>& proxyRequest)
 {
   Command* command;
   if(proxyRequest) {
     std::string options;
-    SharedHandle<SocketCore> pooledSocket;
+    std::shared_ptr<SocketCore> pooledSocket;
     std::string proxyMethod = resolveProxyMethod(getRequest()->getProtocol());
     if(proxyMethod == V_GET) {
       pooledSocket = getDownloadEngine()->popPooledSocket
@@ -112,11 +112,11 @@ Command* FtpInitiateConnectionCommand::createNextCommand
       if(proxyMethod == V_GET) {
         // Use GET for FTP via HTTP proxy.
         getRequest()->setMethod(Request::METHOD_GET);
-        SharedHandle<HttpRequestConnectChain> chain
+        std::shared_ptr<HttpRequestConnectChain> chain
           (new HttpRequestConnectChain());
         c->setControlChain(chain);
       } else if(proxyMethod == V_TUNNEL) {
-        SharedHandle<FtpTunnelRequestConnectChain> chain
+        std::shared_ptr<FtpTunnelRequestConnectChain> chain
           (new FtpTunnelRequestConnectChain());
         c->setControlChain(chain);
       } else {
@@ -141,9 +141,9 @@ Command* FtpInitiateConnectionCommand::createNextCommand
       } else if(proxyMethod == V_GET) {
         // Use GET for FTP via HTTP proxy.
         getRequest()->setMethod(Request::METHOD_GET);
-        SharedHandle<SocketRecvBuffer> socketRecvBuffer
+        std::shared_ptr<SocketRecvBuffer> socketRecvBuffer
           (new SocketRecvBuffer(pooledSocket));
-        SharedHandle<HttpConnection> hc
+        std::shared_ptr<HttpConnection> hc
           (new HttpConnection(getCuid(), pooledSocket, socketRecvBuffer));
 
         HttpRequestCommand* c = new HttpRequestCommand(getCuid(),
@@ -162,7 +162,7 @@ Command* FtpInitiateConnectionCommand::createNextCommand
     }
   } else {
     std::string options;
-    SharedHandle<SocketCore> pooledSocket =
+    std::shared_ptr<SocketCore> pooledSocket =
       getDownloadEngine()->popPooledSocket
       (options, resolvedAddresses,
        getRequest()->getPort(),
@@ -181,7 +181,7 @@ Command* FtpInitiateConnectionCommand::createNextCommand
                                              getRequestGroup(),
                                              getDownloadEngine(),
                                              getSocket());
-      SharedHandle<FtpNegotiationConnectChain> chain
+      std::shared_ptr<FtpNegotiationConnectChain> chain
         (new FtpNegotiationConnectChain());
       c->setControlChain(chain);
       setupBackupConnection(hostname, addr, port, c);
diff --git a/src/FtpInitiateConnectionCommand.h b/src/FtpInitiateConnectionCommand.h
index 38d07609..46cead0d 100644
--- a/src/FtpInitiateConnectionCommand.h
+++ b/src/FtpInitiateConnectionCommand.h
@@ -44,10 +44,10 @@ protected:
   virtual Command* createNextCommand
   (const std::string& hostname, const std::string& addr, uint16_t port,
    const std::vector<std::string>& resolvedAddresses,
-   const SharedHandle<Request>& proxyRequest);
+   const std::shared_ptr<Request>& proxyRequest);
 public:
-  FtpInitiateConnectionCommand(cuid_t cuid, const SharedHandle<Request>& req,
-                               const SharedHandle<FileEntry>& fileEntry,
+  FtpInitiateConnectionCommand(cuid_t cuid, const std::shared_ptr<Request>& req,
+                               const std::shared_ptr<FileEntry>& fileEntry,
                                RequestGroup* requestGroup, DownloadEngine* e);
 
   virtual ~FtpInitiateConnectionCommand();
diff --git a/src/FtpNegotiationCommand.cc b/src/FtpNegotiationCommand.cc
index 8ed30e5b..1845a116 100644
--- a/src/FtpNegotiationCommand.cc
+++ b/src/FtpNegotiationCommand.cc
@@ -82,11 +82,11 @@ namespace aria2 {
 
 FtpNegotiationCommand::FtpNegotiationCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& socket,
+ const std::shared_ptr<SocketCore>& socket,
  Seq seq,
  const std::string& baseWorkingDir):
   AbstractCommand(cuid, req, fileEntry, requestGroup, e, socket),
@@ -401,7 +401,7 @@ bool FtpNegotiationCommand::onFileSizeDetermined(int64_t totalLength)
       getRequestGroup()->initPieceStorage();
       if(getDownloadContext()->isChecksumVerificationNeeded()) {
         A2_LOG_DEBUG("Zero length file exists. Verify checksum.");
-        SharedHandle<ChecksumCheckIntegrityEntry> entry
+        std::shared_ptr<ChecksumCheckIntegrityEntry> entry
           (new ChecksumCheckIntegrityEntry(getRequestGroup()));
         entry->initValidator();
         getPieceStorage()->getDiskAdaptor()->openExistingFile();
@@ -435,7 +435,7 @@ bool FtpNegotiationCommand::onFileSizeDetermined(int64_t totalLength)
       // HttpResponseCommand::handleOtherEncoding()
       if(getDownloadContext()->isChecksumVerificationNeeded()) {
         A2_LOG_DEBUG("Verify checksum for zero-length file");
-        SharedHandle<ChecksumCheckIntegrityEntry> entry
+        std::shared_ptr<ChecksumCheckIntegrityEntry> entry
           (new ChecksumCheckIntegrityEntry(getRequestGroup()));
         entry->initValidator();
         getDownloadEngine()->getCheckIntegrityMan()->pushEntry(entry);
@@ -455,9 +455,9 @@ bool FtpNegotiationCommand::onFileSizeDetermined(int64_t totalLength)
     getSegmentMan()->getSegmentWithIndex(getCuid(), 0);
     return true;
   } else {
-    SharedHandle<BtProgressInfoFile> progressInfoFile
+    std::shared_ptr<BtProgressInfoFile> progressInfoFile
       (new DefaultBtProgressInfoFile
-       (getDownloadContext(), SharedHandle<PieceStorage>(), getOption().get()));
+       (getDownloadContext(), std::shared_ptr<PieceStorage>(), getOption().get()));
     getRequestGroup()->adjustFilename(progressInfoFile);
     getRequestGroup()->initPieceStorage();
 
@@ -466,7 +466,7 @@ bool FtpNegotiationCommand::onFileSizeDetermined(int64_t totalLength)
       return false;
     }
 
-    SharedHandle<CheckIntegrityEntry> checkIntegrityEntry =
+    std::shared_ptr<CheckIntegrityEntry> checkIntegrityEntry =
       getRequestGroup()->createCheckIntegrityEntry();
     if(!checkIntegrityEntry) {
       sequence_ = SEQ_DOWNLOAD_ALREADY_COMPLETED;
@@ -684,7 +684,7 @@ bool FtpNegotiationCommand::preparePasvConnect() {
 
 bool FtpNegotiationCommand::resolveProxy()
 {
-  SharedHandle<Request> proxyReq = createProxyRequest();
+  std::shared_ptr<Request> proxyReq = createProxyRequest();
   std::vector<std::string> addrs;
   proxyAddr_ = resolveHostname
     (addrs, proxyReq->getHost(), proxyReq->getPort());
@@ -698,7 +698,7 @@ bool FtpNegotiationCommand::resolveProxy()
   dataSocket_->establishConnection(proxyAddr_, proxyReq->getPort());
   disableReadCheckSocket();
   setWriteCheckSocket(dataSocket_);
-  SharedHandle<SocketRecvBuffer> socketRecvBuffer
+  std::shared_ptr<SocketRecvBuffer> socketRecvBuffer
     (new SocketRecvBuffer(dataSocket_));
   http_.reset(new HttpConnection(getCuid(), dataSocket_, socketRecvBuffer));
   sequence_ = SEQ_SEND_TUNNEL_REQUEST;
@@ -711,7 +711,7 @@ bool FtpNegotiationCommand::sendTunnelRequest()
     if(dataSocket_->isReadable(0)) {
       std::string error = getSocket()->getSocketError();
       if(!error.empty()) {
-        SharedHandle<Request> proxyReq = createProxyRequest();
+        std::shared_ptr<Request> proxyReq = createProxyRequest();
         getDownloadEngine()->markBadIPAddress(proxyReq->getHost(),
                                               proxyAddr_,proxyReq->getPort());
         std::string nextProxyAddr = getDownloadEngine()->findCachedIPAddress
@@ -735,9 +735,9 @@ bool FtpNegotiationCommand::sendTunnelRequest()
         }
       }
     }
-    SharedHandle<HttpRequest> httpRequest(new HttpRequest());
+    std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
     httpRequest->setUserAgent(getOption()->get(PREF_USER_AGENT));
-    SharedHandle<Request> req(new Request());
+    std::shared_ptr<Request> req(new Request());
     // Construct fake URI in order to use HttpRequest
     std::pair<std::string, uint16_t> dataAddr;
     uri::UriStruct us;
@@ -767,7 +767,7 @@ bool FtpNegotiationCommand::sendTunnelRequest()
 
 bool FtpNegotiationCommand::recvTunnelResponse()
 {
-  SharedHandle<HttpResponse> httpResponse = http_->receiveResponse();
+  std::shared_ptr<HttpResponse> httpResponse = http_->receiveResponse();
   if(!httpResponse) {
     return false;
   }
@@ -778,7 +778,7 @@ bool FtpNegotiationCommand::recvTunnelResponse()
   return true;
 }
 
-bool FtpNegotiationCommand::sendRestPasv(const SharedHandle<Segment>& segment) {
+bool FtpNegotiationCommand::sendRestPasv(const std::shared_ptr<Segment>& segment) {
   //dataSocket_->setBlockingMode();
   // Check connection is made properly
   if(dataSocket_->isReadable(0)) {
@@ -792,7 +792,7 @@ bool FtpNegotiationCommand::sendRestPasv(const SharedHandle<Segment>& segment) {
   return sendRest(segment);
 }
 
-bool FtpNegotiationCommand::sendRest(const SharedHandle<Segment>& segment) {
+bool FtpNegotiationCommand::sendRest(const std::shared_ptr<Segment>& segment) {
   if(ftp_->sendRest(segment)) {
     disableWriteCheckSocket();
     sequence_ = SEQ_RECV_REST;
@@ -802,7 +802,7 @@ bool FtpNegotiationCommand::sendRest(const SharedHandle<Segment>& segment) {
   return false;
 }
 
-bool FtpNegotiationCommand::recvRest(const SharedHandle<Segment>& segment) {
+bool FtpNegotiationCommand::recvRest(const std::shared_ptr<Segment>& segment) {
   int status = ftp_->receiveResponse();
   if(status == 0) {
     return false;
@@ -864,7 +864,7 @@ bool FtpNegotiationCommand::waitConnection()
 }
 
 bool FtpNegotiationCommand::processSequence
-(const SharedHandle<Segment>& segment) {
+(const std::shared_ptr<Segment>& segment) {
   bool doNextSequence = true;
   switch(sequence_) {
   case SEQ_RECV_GREETING:
diff --git a/src/FtpNegotiationCommand.h b/src/FtpNegotiationCommand.h
index 07e4c228..9fa5ad1d 100644
--- a/src/FtpNegotiationCommand.h
+++ b/src/FtpNegotiationCommand.h
@@ -125,13 +125,13 @@ private:
   bool resolveProxy();
   bool sendTunnelRequest();
   bool recvTunnelResponse();
-  bool sendRest(const SharedHandle<Segment>& segment);
-  bool sendRestPasv(const SharedHandle<Segment>& segment);
-  bool recvRest(const SharedHandle<Segment>& segment);
+  bool sendRest(const std::shared_ptr<Segment>& segment);
+  bool sendRestPasv(const std::shared_ptr<Segment>& segment);
+  bool recvRest(const std::shared_ptr<Segment>& segment);
   bool sendRetr();
   bool recvRetr();
   bool waitConnection();
-  bool processSequence(const SharedHandle<Segment>& segment);
+  bool processSequence(const std::shared_ptr<Segment>& segment);
 
   void afterFileAllocation();
 
@@ -141,12 +141,12 @@ private:
 
   void onDryRunFileFound();
 
-  SharedHandle<SocketCore> dataSocket_;
-  SharedHandle<SocketCore> serverSocket_;
+  std::shared_ptr<SocketCore> dataSocket_;
+  std::shared_ptr<SocketCore> serverSocket_;
   Seq sequence_;
-  SharedHandle<FtpConnection> ftp_;
+  std::shared_ptr<FtpConnection> ftp_;
   // For tunneling
-  SharedHandle<HttpConnection> http_;
+  std::shared_ptr<HttpConnection> http_;
   // Port number in PASV/EPSV response
   uint16_t pasvPort_;
   // Resolved address for proxy
@@ -157,11 +157,11 @@ protected:
   virtual bool executeInternal();
 public:
   FtpNegotiationCommand(cuid_t cuid,
-                        const SharedHandle<Request>& req,
-                        const SharedHandle<FileEntry>& fileEntry,
+                        const std::shared_ptr<Request>& req,
+                        const std::shared_ptr<FileEntry>& fileEntry,
                         RequestGroup* requestGroup,
                         DownloadEngine* e,
-                        const SharedHandle<SocketCore>& s,
+                        const std::shared_ptr<SocketCore>& s,
                         Seq seq = SEQ_RECV_GREETING,
                         const std::string& baseWorkingDir = "/");
   virtual ~FtpNegotiationCommand();
diff --git a/src/FtpTunnelRequestCommand.cc b/src/FtpTunnelRequestCommand.cc
index 2ca92895..72ea099b 100644
--- a/src/FtpTunnelRequestCommand.cc
+++ b/src/FtpTunnelRequestCommand.cc
@@ -43,12 +43,12 @@ namespace aria2 {
 
 FtpTunnelRequestCommand::FtpTunnelRequestCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e,
- const SharedHandle<Request>& proxyRequest,
- const SharedHandle<SocketCore>& s)
+ const std::shared_ptr<Request>& proxyRequest,
+ const std::shared_ptr<SocketCore>& s)
   :
   AbstractProxyRequestCommand(cuid, req, fileEntry, requestGroup, e,
                               proxyRequest, s)
diff --git a/src/FtpTunnelRequestCommand.h b/src/FtpTunnelRequestCommand.h
index c22ff381..2e2bb6f5 100644
--- a/src/FtpTunnelRequestCommand.h
+++ b/src/FtpTunnelRequestCommand.h
@@ -44,12 +44,12 @@ class SocketCore;
 class FtpTunnelRequestCommand : public AbstractProxyRequestCommand {
 public:
   FtpTunnelRequestCommand(cuid_t cuid,
-                          const SharedHandle<Request>& req,
-                          const SharedHandle<FileEntry>& fileEntry,
+                          const std::shared_ptr<Request>& req,
+                          const std::shared_ptr<FileEntry>& fileEntry,
                           RequestGroup* requestGroup,
                           DownloadEngine* e,
-                          const SharedHandle<Request>& proxyRequest,
-                          const SharedHandle<SocketCore>& s);
+                          const std::shared_ptr<Request>& proxyRequest,
+                          const std::shared_ptr<SocketCore>& s);
   virtual ~FtpTunnelRequestCommand();
 
   virtual Command* getNextCommand();
diff --git a/src/FtpTunnelResponseCommand.cc b/src/FtpTunnelResponseCommand.cc
index abafea18..bc218400 100644
--- a/src/FtpTunnelResponseCommand.cc
+++ b/src/FtpTunnelResponseCommand.cc
@@ -45,12 +45,12 @@ namespace aria2 {
 
 FtpTunnelResponseCommand::FtpTunnelResponseCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
- const SharedHandle<HttpConnection>& httpConnection,
+ const std::shared_ptr<HttpConnection>& httpConnection,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& s)
+ const std::shared_ptr<SocketCore>& s)
   :AbstractProxyResponseCommand(cuid, req, fileEntry, requestGroup,
                                 httpConnection,e, s)
 {}
diff --git a/src/FtpTunnelResponseCommand.h b/src/FtpTunnelResponseCommand.h
index fae4b427..b80ef8ff 100644
--- a/src/FtpTunnelResponseCommand.h
+++ b/src/FtpTunnelResponseCommand.h
@@ -44,12 +44,12 @@ class SocketCore;
 class FtpTunnelResponseCommand : public AbstractProxyResponseCommand {
 public:
   FtpTunnelResponseCommand(cuid_t cuid,
-                           const SharedHandle<Request>& req,
-                           const SharedHandle<FileEntry>& fileEntry,
+                           const std::shared_ptr<Request>& req,
+                           const std::shared_ptr<FileEntry>& fileEntry,
                            RequestGroup* requestGroup,
-                           const SharedHandle<HttpConnection>& httpConnection,
+                           const std::shared_ptr<HttpConnection>& httpConnection,
                            DownloadEngine* e,
-                           const SharedHandle<SocketCore>& s);
+                           const std::shared_ptr<SocketCore>& s);
   virtual ~FtpTunnelResponseCommand();
 
   virtual Command* getNextCommand();
diff --git a/src/GZipDecodingStreamFilter.cc b/src/GZipDecodingStreamFilter.cc
index 67559cbe..58fef107 100644
--- a/src/GZipDecodingStreamFilter.cc
+++ b/src/GZipDecodingStreamFilter.cc
@@ -44,7 +44,7 @@ namespace aria2 {
 const std::string GZipDecodingStreamFilter::NAME("GZipDecodingStreamFilter");
 
 GZipDecodingStreamFilter::GZipDecodingStreamFilter
-(const SharedHandle<StreamFilter>& delegate):
+(const std::shared_ptr<StreamFilter>& delegate):
   StreamFilter(delegate), strm_(0), finished_(false), bytesProcessed_(0) {}
 
 GZipDecodingStreamFilter::~GZipDecodingStreamFilter()
@@ -79,8 +79,8 @@ void GZipDecodingStreamFilter::release()
 }
 
 ssize_t GZipDecodingStreamFilter::transform
-(const SharedHandle<BinaryStream>& out,
- const SharedHandle<Segment>& segment,
+(const std::shared_ptr<BinaryStream>& out,
+ const std::shared_ptr<Segment>& segment,
  const unsigned char* inbuf, size_t inlen)
 {
   bytesProcessed_ = 0;
diff --git a/src/GZipDecodingStreamFilter.h b/src/GZipDecodingStreamFilter.h
index 349bc8e5..1c812d75 100644
--- a/src/GZipDecodingStreamFilter.h
+++ b/src/GZipDecodingStreamFilter.h
@@ -52,14 +52,14 @@ private:
   static const size_t OUTBUF_LENGTH = 16*1024;
 public:
   GZipDecodingStreamFilter
-  (const SharedHandle<StreamFilter>& delegate = SharedHandle<StreamFilter>());
+  (const std::shared_ptr<StreamFilter>& delegate = std::shared_ptr<StreamFilter>());
 
   virtual ~GZipDecodingStreamFilter();
 
   virtual void init();
 
-  virtual ssize_t transform(const SharedHandle<BinaryStream>& out,
-                            const SharedHandle<Segment>& segment,
+  virtual ssize_t transform(const std::shared_ptr<BinaryStream>& out,
+                            const std::shared_ptr<Segment>& segment,
                             const unsigned char* inbuf, size_t inlen);
 
   virtual bool finished();
diff --git a/src/GenericParser.h b/src/GenericParser.h
index b4930498..1870328a 100644
--- a/src/GenericParser.h
+++ b/src/GenericParser.h
@@ -36,7 +36,6 @@
 #define D_GENERIC_PARSER_H
 
 #include "common.h"
-#include "SharedHandle.h"
 #include "a2io.h"
 #include "util.h"
 
diff --git a/src/GroupId.cc b/src/GroupId.cc
index a5c9d4ea..8d1f1dfc 100644
--- a/src/GroupId.cc
+++ b/src/GroupId.cc
@@ -33,13 +33,16 @@
  */
 /* copyright --> */
 #include "GroupId.h"
+
+#include <cassert>
+
 #include "util.h"
 
 namespace aria2 {
 
 std::set<a2_gid_t> GroupId::set_;
 
-SharedHandle<GroupId> GroupId::create()
+std::shared_ptr<GroupId> GroupId::create()
 {
   a2_gid_t n;
   for(;;) {
@@ -48,13 +51,13 @@ SharedHandle<GroupId> GroupId::create()
       break;
     }
   }
-  SharedHandle<GroupId> res(new GroupId(n));
+  std::shared_ptr<GroupId> res(new GroupId(n));
   return res;
 }
 
-SharedHandle<GroupId> GroupId::import(a2_gid_t n)
+std::shared_ptr<GroupId> GroupId::import(a2_gid_t n)
 {
-  SharedHandle<GroupId> res;
+  std::shared_ptr<GroupId> res;
   if(n == 0 || set_.count(n) != 0) {
     return res;
   }
diff --git a/src/GroupId.h b/src/GroupId.h
index 25e3c4f2..6d608edf 100644
--- a/src/GroupId.h
+++ b/src/GroupId.h
@@ -39,8 +39,7 @@
 
 #include <set>
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -48,8 +47,8 @@ typedef uint64_t a2_gid_t;
 
 class GroupId {
 public:
-  static SharedHandle<GroupId> create();
-  static SharedHandle<GroupId> import(a2_gid_t n);
+  static std::shared_ptr<GroupId> create();
+  static std::shared_ptr<GroupId> import(a2_gid_t n);
   static void clear();
   enum {
     ERR_NOT_UNIQUE = -1,
diff --git a/src/GrowSegment.cc b/src/GrowSegment.cc
index 70649fc2..c176cdde 100644
--- a/src/GrowSegment.cc
+++ b/src/GrowSegment.cc
@@ -38,7 +38,7 @@
 
 namespace aria2 {
 
-GrowSegment::GrowSegment(const SharedHandle<Piece>& piece):
+GrowSegment::GrowSegment(const std::shared_ptr<Piece>& piece):
   piece_(piece), writtenLength_(0) {}
 
 GrowSegment::~GrowSegment() {}
@@ -66,7 +66,7 @@ void GrowSegment::clear(WrDiskCache* diskCache)
   piece_->clearAllBlock(0);
 }
 
-SharedHandle<Piece> GrowSegment::getPiece() const
+std::shared_ptr<Piece> GrowSegment::getPiece() const
 {
   return piece_;
 }
diff --git a/src/GrowSegment.h b/src/GrowSegment.h
index b108ef40..b16c0f56 100644
--- a/src/GrowSegment.h
+++ b/src/GrowSegment.h
@@ -41,10 +41,10 @@ namespace aria2 {
 
 class GrowSegment:public Segment {
 private:
-  SharedHandle<Piece> piece_;
+  std::shared_ptr<Piece> piece_;
   int32_t writtenLength_;
 public:
-  GrowSegment(const SharedHandle<Piece>& piece);
+  GrowSegment(const std::shared_ptr<Piece>& piece);
 
   virtual ~GrowSegment();
 
@@ -106,7 +106,7 @@ public:
 
   virtual void clear(WrDiskCache* diskCache);
 
-  virtual SharedHandle<Piece> getPiece() const;
+  virtual std::shared_ptr<Piece> getPiece() const;
 };
 
 } // namespace aria2
diff --git a/src/HandshakeExtensionMessage.cc b/src/HandshakeExtensionMessage.cc
index df2d23c5..1a39e782 100644
--- a/src/HandshakeExtensionMessage.cc
+++ b/src/HandshakeExtensionMessage.cc
@@ -67,7 +67,7 @@ std::string HandshakeExtensionMessage::getPayload()
   if(tcpPort_ > 0) {
     dict.put("p", Integer::g(tcpPort_));
   }
-  SharedHandle<Dict> extDict = Dict::g();
+  std::shared_ptr<Dict> extDict = Dict::g();
   for(int i = 0; i < ExtensionMessageRegistry::MAX_EXTENSION; ++i) {
     int id = extreg_.getExtensionMessageID(i);
     if(id) {
@@ -109,7 +109,7 @@ void HandshakeExtensionMessage::doReceivedAction()
       peer_->setExtension(i, id);
     }
   }
-  SharedHandle<TorrentAttribute> attrs = bittorrent::getTorrentAttrs(dctx_);
+  std::shared_ptr<TorrentAttribute> attrs = bittorrent::getTorrentAttrs(dctx_);
   if(attrs->metadata.empty()) {
     if(!peer_->getExtensionMessageID(ExtensionMessageRegistry::UT_METADATA)) {
       // TODO In metadataGetMode, if peer don't support metadata
@@ -128,7 +128,7 @@ void HandshakeExtensionMessage::doReceivedAction()
         dctx_->markTotalLengthIsKnown();
         dctx_->getOwnerRequestGroup()->initPieceStorage();
 
-        SharedHandle<PieceStorage> pieceStorage =
+        std::shared_ptr<PieceStorage> pieceStorage =
           dctx_->getOwnerRequestGroup()->getPieceStorage();
         // We enter 'end game' mode from the start to get metadata
         // quickly.
@@ -144,7 +144,7 @@ void HandshakeExtensionMessage::doReceivedAction()
   }
 }
 
-void HandshakeExtensionMessage::setPeer(const SharedHandle<Peer>& peer)
+void HandshakeExtensionMessage::setPeer(const std::shared_ptr<Peer>& peer)
 {
   peer_ = peer;
 }
@@ -174,7 +174,7 @@ HandshakeExtensionMessage::create(const unsigned char* data, size_t length)
   }
   A2_LOG_DEBUG(fmt("Creating HandshakeExtensionMessage from %s",
                    util::percentEncode(data, length).c_str()));
-  SharedHandle<ValueBase> decoded = bencode2::decode(data+1, length - 1);
+  std::shared_ptr<ValueBase> decoded = bencode2::decode(data+1, length - 1);
   const Dict* dict = downcast<Dict>(decoded);
   if(!dict) {
     throw DL_ABORT_EX
diff --git a/src/HandshakeExtensionMessage.h b/src/HandshakeExtensionMessage.h
index 3c1c2e55..520b8a9c 100644
--- a/src/HandshakeExtensionMessage.h
+++ b/src/HandshakeExtensionMessage.h
@@ -37,9 +37,10 @@
 
 #include "ExtensionMessage.h"
 
+#include <memory>
+
 #include "BtConstants.h"
 #include "ExtensionMessageRegistry.h"
-#include "SharedHandle.h"
 
 namespace aria2 {
 
@@ -56,9 +57,9 @@ private:
 
   ExtensionMessageRegistry extreg_;
 
-  SharedHandle<DownloadContext> dctx_;
+  std::shared_ptr<DownloadContext> dctx_;
 
-  SharedHandle<Peer> peer_;
+  std::shared_ptr<Peer> peer_;
 public:
   HandshakeExtensionMessage();
 
@@ -112,7 +113,7 @@ public:
     metadataSize_ = size;
   }
 
-  void setDownloadContext(const SharedHandle<DownloadContext>& dctx)
+  void setDownloadContext(const std::shared_ptr<DownloadContext>& dctx)
   {
     dctx_ = dctx;
   }
@@ -123,7 +124,7 @@ public:
 
   uint8_t getExtensionMessageID(int key) const;
 
-  void setPeer(const SharedHandle<Peer>& peer);
+  void setPeer(const std::shared_ptr<Peer>& peer);
 
   static HandshakeExtensionMessage*
   create(const unsigned char* data, size_t dataLength);
diff --git a/src/HaveEraseCommand.cc b/src/HaveEraseCommand.cc
index 69e7b817..e2727909 100644
--- a/src/HaveEraseCommand.cc
+++ b/src/HaveEraseCommand.cc
@@ -59,7 +59,7 @@ void HaveEraseCommand::process()
     getDownloadEngine()->getRequestGroupMan()->getRequestGroups();
   for(RequestGroupList::const_iterator i = groups.begin(),
         eoi = groups.end(); i != eoi; ++i) {
-    const SharedHandle<PieceStorage>& ps = (*i)->getPieceStorage();
+    const std::shared_ptr<PieceStorage>& ps = (*i)->getPieceStorage();
     if(ps) {
       ps->removeAdvertisedPiece(5);
     }
diff --git a/src/HttpConnection.cc b/src/HttpConnection.cc
index 84e3461f..78fe8164 100644
--- a/src/HttpConnection.cc
+++ b/src/HttpConnection.cc
@@ -62,7 +62,7 @@
 namespace aria2 {
 
 HttpRequestEntry::HttpRequestEntry
-(const SharedHandle<HttpRequest>& httpRequest)
+(const std::shared_ptr<HttpRequest>& httpRequest)
   : httpRequest_(httpRequest),
     proc_(new HttpHeaderProcessor(HttpHeaderProcessor::CLIENT_PARSER))
 {}
@@ -71,8 +71,8 @@ HttpRequestEntry::~HttpRequestEntry() {}
 
 HttpConnection::HttpConnection
 (cuid_t cuid,
- const SharedHandle<SocketCore>& socket,
- const SharedHandle<SocketRecvBuffer>& socketRecvBuffer)
+ const std::shared_ptr<SocketCore>& socket,
+ const std::shared_ptr<SocketRecvBuffer>& socketRecvBuffer)
   : cuid_(cuid),
     socket_(socket),
     socketRecvBuffer_(socketRecvBuffer),
@@ -99,7 +99,7 @@ std::string HttpConnection::eraseConfidentialInfo(const std::string& request)
   return result;
 }
 
-void HttpConnection::sendRequest(const SharedHandle<HttpRequest>& httpRequest)
+void HttpConnection::sendRequest(const std::shared_ptr<HttpRequest>& httpRequest)
 {
   std::string request = httpRequest->createRequest();
   A2_LOG_INFO(fmt(MSG_SENDING_REQUEST,
@@ -107,12 +107,12 @@ void HttpConnection::sendRequest(const SharedHandle<HttpRequest>& httpRequest)
                   eraseConfidentialInfo(request).c_str()));
   socketBuffer_.pushStr(request);
   socketBuffer_.send();
-  SharedHandle<HttpRequestEntry> entry(new HttpRequestEntry(httpRequest));
+  std::shared_ptr<HttpRequestEntry> entry(new HttpRequestEntry(httpRequest));
   outstandingHttpRequests_.push_back(entry);
 }
 
 void HttpConnection::sendProxyRequest
-(const SharedHandle<HttpRequest>& httpRequest)
+(const std::shared_ptr<HttpRequest>& httpRequest)
 {
   std::string request = httpRequest->createProxyRequest();
   A2_LOG_INFO(fmt(MSG_SENDING_REQUEST,
@@ -120,17 +120,17 @@ void HttpConnection::sendProxyRequest
                   eraseConfidentialInfo(request).c_str()));
   socketBuffer_.pushStr(request);
   socketBuffer_.send();
-  SharedHandle<HttpRequestEntry> entry(new HttpRequestEntry(httpRequest));
+  std::shared_ptr<HttpRequestEntry> entry(new HttpRequestEntry(httpRequest));
   outstandingHttpRequests_.push_back(entry);
 }
 
-SharedHandle<HttpResponse> HttpConnection::receiveResponse()
+std::shared_ptr<HttpResponse> HttpConnection::receiveResponse()
 {
   if(outstandingHttpRequests_.empty()) {
     throw DL_ABORT_EX(EX_NO_HTTP_REQUEST_ENTRY_FOUND);
   }
-  SharedHandle<HttpRequestEntry> entry = outstandingHttpRequests_.front();
-  const SharedHandle<HttpHeaderProcessor>& proc =
+  std::shared_ptr<HttpRequestEntry> entry = outstandingHttpRequests_.front();
+  const std::shared_ptr<HttpHeaderProcessor>& proc =
     entry->getHttpHeaderProcessor();
   if(socketRecvBuffer_->bufferEmpty()) {
     if(socketRecvBuffer_->recv() == 0 &&
@@ -138,10 +138,10 @@ SharedHandle<HttpResponse> HttpConnection::receiveResponse()
       throw DL_RETRY_EX(EX_GOT_EOF);
     }
   }
-  SharedHandle<HttpResponse> httpResponse;
+  std::shared_ptr<HttpResponse> httpResponse;
   if(proc->parse(socketRecvBuffer_->getBuffer(),
                  socketRecvBuffer_->getBufferLength())) {
-    const SharedHandle<HttpHeader>& httpHeader = proc->getResult();
+    const std::shared_ptr<HttpHeader>& httpHeader = proc->getResult();
     A2_LOG_INFO(fmt(MSG_RECEIVE_RESPONSE,
                     cuid_,
                     proc->getHeaderString().c_str()));
@@ -155,11 +155,11 @@ SharedHandle<HttpResponse> HttpConnection::receiveResponse()
   return httpResponse;
 }
 
-bool HttpConnection::isIssued(const SharedHandle<Segment>& segment) const
+bool HttpConnection::isIssued(const std::shared_ptr<Segment>& segment) const
 {
   for(HttpRequestEntries::const_iterator itr = outstandingHttpRequests_.begin(),
         eoi = outstandingHttpRequests_.end(); itr != eoi; ++itr) {
-    SharedHandle<HttpRequest> httpRequest = (*itr)->getHttpRequest();
+    std::shared_ptr<HttpRequest> httpRequest = (*itr)->getHttpRequest();
     if(*httpRequest->getSegment() == *segment) {
       return true;
     }
@@ -167,10 +167,10 @@ bool HttpConnection::isIssued(const SharedHandle<Segment>& segment) const
   return false;
 }
 
-SharedHandle<HttpRequest> HttpConnection::getFirstHttpRequest() const
+std::shared_ptr<HttpRequest> HttpConnection::getFirstHttpRequest() const
 {
   if(outstandingHttpRequests_.empty()) {
-    return SharedHandle<HttpRequest>();
+    return std::shared_ptr<HttpRequest>();
   } else {
     return outstandingHttpRequests_.front()->getHttpRequest();
   }
diff --git a/src/HttpConnection.h b/src/HttpConnection.h
index d7c2cc0c..b46f9461 100644
--- a/src/HttpConnection.h
+++ b/src/HttpConnection.h
@@ -39,8 +39,8 @@
 
 #include <string>
 #include <deque>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "SocketBuffer.h"
 #include "Command.h"
 
@@ -56,31 +56,31 @@ class SocketRecvBuffer;
 
 class HttpRequestEntry {
 private:
-  SharedHandle<HttpRequest> httpRequest_;
-  SharedHandle<HttpHeaderProcessor> proc_;
+  std::shared_ptr<HttpRequest> httpRequest_;
+  std::shared_ptr<HttpHeaderProcessor> proc_;
 public:
-  HttpRequestEntry(const SharedHandle<HttpRequest>& httpRequest);
+  HttpRequestEntry(const std::shared_ptr<HttpRequest>& httpRequest);
 
   ~HttpRequestEntry();
 
-  const SharedHandle<HttpRequest>& getHttpRequest() const
+  const std::shared_ptr<HttpRequest>& getHttpRequest() const
   {
     return httpRequest_;
   }
 
-  const SharedHandle<HttpHeaderProcessor>& getHttpHeaderProcessor() const
+  const std::shared_ptr<HttpHeaderProcessor>& getHttpHeaderProcessor() const
   {
     return proc_;
   }
 };
 
-typedef std::deque<SharedHandle<HttpRequestEntry> > HttpRequestEntries;
+typedef std::deque<std::shared_ptr<HttpRequestEntry> > HttpRequestEntries;
 
 class HttpConnection {
 private:
   cuid_t cuid_;
-  SharedHandle<SocketCore> socket_;
-  SharedHandle<SocketRecvBuffer> socketRecvBuffer_;
+  std::shared_ptr<SocketCore> socket_;
+  std::shared_ptr<SocketRecvBuffer> socketRecvBuffer_;
   SocketBuffer socketBuffer_;
 
   HttpRequestEntries outstandingHttpRequests_;
@@ -89,8 +89,8 @@ private:
 public:
   HttpConnection
   (cuid_t cuid,
-   const SharedHandle<SocketCore>& socket,
-   const SharedHandle<SocketRecvBuffer>& socketRecvBuffer);
+   const std::shared_ptr<SocketCore>& socket,
+   const std::shared_ptr<SocketRecvBuffer>& socketRecvBuffer);
   ~HttpConnection();
 
   /**
@@ -100,12 +100,12 @@ public:
    * HTTP proxy(GET method).
    * @param segment indicates starting postion of the file for downloading
    */
-  void sendRequest(const SharedHandle<HttpRequest>& httpRequest);
+  void sendRequest(const std::shared_ptr<HttpRequest>& httpRequest);
 
   /**
    * Sends Http proxy request using CONNECT method.
    */
-  void sendProxyRequest(const SharedHandle<HttpRequest>& httpRequest);
+  void sendProxyRequest(const std::shared_ptr<HttpRequest>& httpRequest);
 
   /**
    * Receives HTTP response from the server and returns HttpResponseHandle
@@ -118,17 +118,17 @@ public:
    *
    * @return HttpResponse or 0 if whole response header is not received
    */
-  SharedHandle<HttpResponse> receiveResponse();
+  std::shared_ptr<HttpResponse> receiveResponse();
 
-  SharedHandle<HttpRequest> getFirstHttpRequest() const;
+  std::shared_ptr<HttpRequest> getFirstHttpRequest() const;
 
-  bool isIssued(const SharedHandle<Segment>& segment) const;
+  bool isIssued(const std::shared_ptr<Segment>& segment) const;
 
   bool sendBufferIsEmpty() const;
 
   void sendPendingData();
 
-  const SharedHandle<SocketRecvBuffer>& getSocketRecvBuffer() const
+  const std::shared_ptr<SocketRecvBuffer>& getSocketRecvBuffer() const
   {
     return socketRecvBuffer_;
   }
diff --git a/src/HttpDownloadCommand.cc b/src/HttpDownloadCommand.cc
index 74153d4d..3436bb58 100644
--- a/src/HttpDownloadCommand.cc
+++ b/src/HttpDownloadCommand.cc
@@ -57,13 +57,13 @@ namespace aria2 {
 
 HttpDownloadCommand::HttpDownloadCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
- const SharedHandle<HttpResponse>& httpResponse,
- const SharedHandle<HttpConnection>& httpConnection,
+ const std::shared_ptr<HttpResponse>& httpResponse,
+ const std::shared_ptr<HttpConnection>& httpConnection,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& socket)
+ const std::shared_ptr<SocketCore>& socket)
   : DownloadCommand(cuid, req, fileEntry, requestGroup, e, socket,
                     httpConnection->getSocketRecvBuffer()),
     httpResponse_(httpResponse),
@@ -115,7 +115,7 @@ bool HttpDownloadCommand::prepareForNextSegment() {
     if(!getRequest()->isPipeliningEnabled() &&
        getRequest()->isPipeliningHint() &&
        !downloadFinished) {
-      const SharedHandle<Segment>& segment = getSegments().front();
+      const std::shared_ptr<Segment>& segment = getSegments().front();
 
       int64_t lastOffset =getFileEntry()->gtoloff
         (std::min(segment->getPosition()+segment->getLength(),
diff --git a/src/HttpDownloadCommand.h b/src/HttpDownloadCommand.h
index 491933aa..486da7b9 100644
--- a/src/HttpDownloadCommand.h
+++ b/src/HttpDownloadCommand.h
@@ -44,20 +44,20 @@ class HttpConnection;
 
 class HttpDownloadCommand : public DownloadCommand {
 private:
-  SharedHandle<HttpResponse> httpResponse_;
-  SharedHandle<HttpConnection> httpConnection_;
+  std::shared_ptr<HttpResponse> httpResponse_;
+  std::shared_ptr<HttpConnection> httpConnection_;
 protected:
   virtual bool prepareForNextSegment();
   virtual int64_t getRequestEndOffset() const;
 public:
   HttpDownloadCommand(cuid_t cuid,
-                      const SharedHandle<Request>& req,
-                      const SharedHandle<FileEntry>& fileEntry,
+                      const std::shared_ptr<Request>& req,
+                      const std::shared_ptr<FileEntry>& fileEntry,
                       RequestGroup* requestGroup,
-                      const SharedHandle<HttpResponse>& httpResponse,
-                      const SharedHandle<HttpConnection>& httpConnection,
+                      const std::shared_ptr<HttpResponse>& httpResponse,
+                      const std::shared_ptr<HttpConnection>& httpConnection,
                       DownloadEngine* e,
-                      const SharedHandle<SocketCore>& s);
+                      const std::shared_ptr<SocketCore>& s);
   virtual ~HttpDownloadCommand();
 };
 
diff --git a/src/HttpHeader.h b/src/HttpHeader.h
index 5f9ef676..ff075e6d 100644
--- a/src/HttpHeader.h
+++ b/src/HttpHeader.h
@@ -41,8 +41,6 @@
 #include <vector>
 #include <string>
 
-#include "SharedHandle.h"
-
 namespace aria2 {
 
 struct Range;
diff --git a/src/HttpHeaderProcessor.cc b/src/HttpHeaderProcessor.cc
index 6b85524a..d7c4f59b 100644
--- a/src/HttpHeaderProcessor.cc
+++ b/src/HttpHeaderProcessor.cc
@@ -391,7 +391,7 @@ void HttpHeaderProcessor::clear()
   headers_.clear();
 }
 
-const SharedHandle<HttpHeader>& HttpHeaderProcessor::getResult() const
+const std::shared_ptr<HttpHeader>& HttpHeaderProcessor::getResult() const
 {
   return result_;
 }
diff --git a/src/HttpHeaderProcessor.h b/src/HttpHeaderProcessor.h
index d8912f72..180eea05 100644
--- a/src/HttpHeaderProcessor.h
+++ b/src/HttpHeaderProcessor.h
@@ -39,8 +39,7 @@
 
 #include <utility>
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -74,7 +73,7 @@ public:
    * Processes the received header as a http response header and returns
    * HttpHeader object.
    */
-  const SharedHandle<HttpHeader>& getResult() const;
+  const std::shared_ptr<HttpHeader>& getResult() const;
 
   std::string getHeaderString() const;
 
@@ -89,7 +88,7 @@ private:
   std::string buf_;
   std::string lastFieldName_;
   int lastFieldHdKey_;
-  SharedHandle<HttpHeader> result_;
+  std::shared_ptr<HttpHeader> result_;
   std::string headers_;
 };
 
diff --git a/src/HttpInitiateConnectionCommand.cc b/src/HttpInitiateConnectionCommand.cc
index e908dc65..cc8b2ef1 100644
--- a/src/HttpInitiateConnectionCommand.cc
+++ b/src/HttpInitiateConnectionCommand.cc
@@ -60,8 +60,8 @@ namespace aria2 {
 
 HttpInitiateConnectionCommand::HttpInitiateConnectionCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e)
   : InitiateConnectionCommand(cuid, req, fileEntry, requestGroup, e)
@@ -72,11 +72,11 @@ HttpInitiateConnectionCommand::~HttpInitiateConnectionCommand() {}
 Command* HttpInitiateConnectionCommand::createNextCommand
 (const std::string& hostname, const std::string& addr, uint16_t port,
  const std::vector<std::string>& resolvedAddresses,
- const SharedHandle<Request>& proxyRequest)
+ const std::shared_ptr<Request>& proxyRequest)
 {
   Command* command;
   if(proxyRequest) {
-    SharedHandle<SocketCore> pooledSocket =
+    std::shared_ptr<SocketCore> pooledSocket =
       getDownloadEngine()->popPooledSocket
       (getRequest()->getHost(), getRequest()->getPort(),
        proxyRequest->getHost(), proxyRequest->getPort());
@@ -96,11 +96,11 @@ Command* HttpInitiateConnectionCommand::createNextCommand
                                              getDownloadEngine(),
                                              getSocket());
       if(proxyMethod == V_TUNNEL) {
-        SharedHandle<HttpProxyRequestConnectChain> chain
+        std::shared_ptr<HttpProxyRequestConnectChain> chain
           (new HttpProxyRequestConnectChain());
         c->setControlChain(chain);
       } else if(proxyMethod == V_GET) {
-        SharedHandle<HttpRequestConnectChain> chain
+        std::shared_ptr<HttpRequestConnectChain> chain
           (new HttpRequestConnectChain());
         c->setControlChain(chain);
       } else {
@@ -111,9 +111,9 @@ Command* HttpInitiateConnectionCommand::createNextCommand
       command = c;
     } else {
       setConnectedAddrInfo(getRequest(), hostname, pooledSocket);
-      SharedHandle<SocketRecvBuffer> socketRecvBuffer
+      std::shared_ptr<SocketRecvBuffer> socketRecvBuffer
         (new SocketRecvBuffer(pooledSocket));
-      SharedHandle<HttpConnection> httpConnection
+      std::shared_ptr<HttpConnection> httpConnection
         (new HttpConnection(getCuid(), pooledSocket, socketRecvBuffer));
       HttpRequestCommand* c = new HttpRequestCommand(getCuid(),
                                                      getRequest(),
@@ -128,7 +128,7 @@ Command* HttpInitiateConnectionCommand::createNextCommand
       command = c;
     }
   } else {
-    SharedHandle<SocketCore> pooledSocket =
+    std::shared_ptr<SocketCore> pooledSocket =
       getDownloadEngine()->popPooledSocket
       (resolvedAddresses, getRequest()->getPort());
     if(!pooledSocket) {
@@ -145,7 +145,7 @@ Command* HttpInitiateConnectionCommand::createNextCommand
                                              getRequestGroup(),
                                              getDownloadEngine(),
                                              getSocket());
-      SharedHandle<HttpRequestConnectChain> chain
+      std::shared_ptr<HttpRequestConnectChain> chain
         (new HttpRequestConnectChain());
       c->setControlChain(chain);
       setupBackupConnection(hostname, addr, port, c);
@@ -154,9 +154,9 @@ Command* HttpInitiateConnectionCommand::createNextCommand
       setSocket(pooledSocket);
       setConnectedAddrInfo(getRequest(), hostname, pooledSocket);
 
-      SharedHandle<SocketRecvBuffer> socketRecvBuffer
+      std::shared_ptr<SocketRecvBuffer> socketRecvBuffer
         (new SocketRecvBuffer(getSocket()));
-      SharedHandle<HttpConnection> httpConnection
+      std::shared_ptr<HttpConnection> httpConnection
         (new HttpConnection(getCuid(), getSocket(), socketRecvBuffer));
       command = new HttpRequestCommand(getCuid(),
                                        getRequest(),
diff --git a/src/HttpInitiateConnectionCommand.h b/src/HttpInitiateConnectionCommand.h
index db104185..a913dc78 100644
--- a/src/HttpInitiateConnectionCommand.h
+++ b/src/HttpInitiateConnectionCommand.h
@@ -71,10 +71,10 @@ protected:
   virtual Command* createNextCommand
   (const std::string& hostname, const std::string& addr, uint16_t port,
    const std::vector<std::string>& resolvedAddresses,
-   const SharedHandle<Request>& proxyRequest);
+   const std::shared_ptr<Request>& proxyRequest);
 public:
-  HttpInitiateConnectionCommand(cuid_t cuid, const SharedHandle<Request>& req,
-                                const SharedHandle<FileEntry>& fileEntry,
+  HttpInitiateConnectionCommand(cuid_t cuid, const std::shared_ptr<Request>& req,
+                                const std::shared_ptr<FileEntry>& fileEntry,
                                 RequestGroup* requestGroup,
                                 DownloadEngine* e);
 
diff --git a/src/HttpListenCommand.cc b/src/HttpListenCommand.cc
index 5115ece0..728faa57 100644
--- a/src/HttpListenCommand.cc
+++ b/src/HttpListenCommand.cc
@@ -72,7 +72,7 @@ bool HttpListenCommand::execute()
   }
   try {
     if(serverSocket_->isReadable(0)) {
-      SharedHandle<SocketCore> socket(serverSocket_->acceptConnection());
+      std::shared_ptr<SocketCore> socket(serverSocket_->acceptConnection());
       socket->setTcpNodelay(true);
       std::pair<std::string, uint16_t> peerInfo;
       socket->getPeerInfo(peerInfo);
diff --git a/src/HttpListenCommand.h b/src/HttpListenCommand.h
index c58700e5..b2d1ee60 100644
--- a/src/HttpListenCommand.h
+++ b/src/HttpListenCommand.h
@@ -36,7 +36,8 @@
 #define D_HTTP_LISTEN_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -47,7 +48,7 @@ class HttpListenCommand : public Command {
 private:
   DownloadEngine* e_;
   int family_;
-  SharedHandle<SocketCore> serverSocket_;
+  std::shared_ptr<SocketCore> serverSocket_;
   bool secure_;
 public:
   HttpListenCommand(cuid_t cuid, DownloadEngine* e, int family, bool secure);
diff --git a/src/HttpProxyRequestCommand.cc b/src/HttpProxyRequestCommand.cc
index 410345ce..2143f398 100644
--- a/src/HttpProxyRequestCommand.cc
+++ b/src/HttpProxyRequestCommand.cc
@@ -42,12 +42,12 @@ namespace aria2 {
 
 HttpProxyRequestCommand::HttpProxyRequestCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e,
- const SharedHandle<Request>& proxyRequest,
- const SharedHandle<SocketCore>& s)
+ const std::shared_ptr<Request>& proxyRequest,
+ const std::shared_ptr<SocketCore>& s)
   :
   AbstractProxyRequestCommand(cuid, req, fileEntry, requestGroup, e,
                               proxyRequest, s)
diff --git a/src/HttpProxyRequestCommand.h b/src/HttpProxyRequestCommand.h
index 60fd6648..ef99ddb2 100644
--- a/src/HttpProxyRequestCommand.h
+++ b/src/HttpProxyRequestCommand.h
@@ -44,12 +44,12 @@ class SocketCore;
 class HttpProxyRequestCommand : public AbstractProxyRequestCommand {
 public:
   HttpProxyRequestCommand(cuid_t cuid,
-                          const SharedHandle<Request>& req,
-                          const SharedHandle<FileEntry>& fileEntry,
+                          const std::shared_ptr<Request>& req,
+                          const std::shared_ptr<FileEntry>& fileEntry,
                           RequestGroup* requestGroup,
                           DownloadEngine* e,
-                          const SharedHandle<Request>& proxyRequest,
-                          const SharedHandle<SocketCore>& s);
+                          const std::shared_ptr<Request>& proxyRequest,
+                          const std::shared_ptr<SocketCore>& s);
   virtual ~HttpProxyRequestCommand();
 
   virtual Command* getNextCommand();
diff --git a/src/HttpProxyResponseCommand.cc b/src/HttpProxyResponseCommand.cc
index 598bac25..cfadc609 100644
--- a/src/HttpProxyResponseCommand.cc
+++ b/src/HttpProxyResponseCommand.cc
@@ -45,12 +45,12 @@ namespace aria2 {
 
 HttpProxyResponseCommand::HttpProxyResponseCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
- const SharedHandle<HttpConnection>& httpConnection,
+ const std::shared_ptr<HttpConnection>& httpConnection,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& s)
+ const std::shared_ptr<SocketCore>& s)
   :AbstractProxyResponseCommand(cuid, req, fileEntry, requestGroup,
                                 httpConnection, e, s)
 {}
diff --git a/src/HttpProxyResponseCommand.h b/src/HttpProxyResponseCommand.h
index 260e79dc..008f7a8b 100644
--- a/src/HttpProxyResponseCommand.h
+++ b/src/HttpProxyResponseCommand.h
@@ -44,12 +44,12 @@ class SocketCore;
 class HttpProxyResponseCommand : public AbstractProxyResponseCommand {
 public:
   HttpProxyResponseCommand(cuid_t cuid,
-                           const SharedHandle<Request>& req,
-                           const SharedHandle<FileEntry>& fileEntry,
+                           const std::shared_ptr<Request>& req,
+                           const std::shared_ptr<FileEntry>& fileEntry,
                            RequestGroup* requestGroup,
-                           const SharedHandle<HttpConnection>& httpConnection,
+                           const std::shared_ptr<HttpConnection>& httpConnection,
                            DownloadEngine* e,
-                           const SharedHandle<SocketCore>& s);
+                           const std::shared_ptr<SocketCore>& s);
   virtual ~HttpProxyResponseCommand();
 
   virtual Command* getNextCommand();
diff --git a/src/HttpRequest.cc b/src/HttpRequest.cc
index 0a55b734..d7320d00 100644
--- a/src/HttpRequest.cc
+++ b/src/HttpRequest.cc
@@ -68,12 +68,12 @@ HttpRequest::HttpRequest():contentEncodingEnabled_(true),
 
 HttpRequest::~HttpRequest() {}
 
-void HttpRequest::setSegment(const SharedHandle<Segment>& segment)
+void HttpRequest::setSegment(const std::shared_ptr<Segment>& segment)
 {
   segment_ = segment;
 }
 
-void HttpRequest::setRequest(const SharedHandle<Request>& request)
+void HttpRequest::setRequest(const std::shared_ptr<Request>& request)
 {
   request_ = request;
 }
@@ -328,34 +328,34 @@ void HttpRequest::clearHeader()
 }
 
 void HttpRequest::setCookieStorage
-(const SharedHandle<CookieStorage>& cookieStorage)
+(const std::shared_ptr<CookieStorage>& cookieStorage)
 {
   cookieStorage_ = cookieStorage;
 }
 
 void HttpRequest::setAuthConfigFactory
-(const SharedHandle<AuthConfigFactory>& factory, const Option* option)
+(const std::shared_ptr<AuthConfigFactory>& factory, const Option* option)
 {
   authConfigFactory_ = factory;
   option_ = option;
 }
 
-void HttpRequest::setProxyRequest(const SharedHandle<Request>& proxyRequest)
+void HttpRequest::setProxyRequest(const std::shared_ptr<Request>& proxyRequest)
 {
   proxyRequest_ = proxyRequest;
 }
 
 bool HttpRequest::isProxyRequestSet() const
 {
-  return proxyRequest_;
+  return proxyRequest_.get();
 }
 
 bool HttpRequest::authenticationUsed() const
 {
-  return authConfig_;
+  return authConfig_.get();
 }
 
-const SharedHandle<AuthConfig>& HttpRequest::getAuthConfig() const
+const std::shared_ptr<AuthConfig>& HttpRequest::getAuthConfig() const
 {
   return authConfig_;
 }
@@ -421,7 +421,7 @@ void HttpRequest::setUserAgent(const std::string& userAgent)
   userAgent_ = userAgent;
 }
 
-void HttpRequest::setFileEntry(const SharedHandle<FileEntry>& fileEntry)
+void HttpRequest::setFileEntry(const std::shared_ptr<FileEntry>& fileEntry)
 {
   fileEntry_ = fileEntry;
 }
diff --git a/src/HttpRequest.h b/src/HttpRequest.h
index 91e30f6d..a9ac38c0 100644
--- a/src/HttpRequest.h
+++ b/src/HttpRequest.h
@@ -40,8 +40,8 @@
 #include <cassert>
 #include <string>
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "FileEntry.h"
 
 namespace aria2 {
@@ -59,11 +59,11 @@ private:
 
   static const std::string USER_AGENT;
 
-  SharedHandle<Request> request_;
+  std::shared_ptr<Request> request_;
 
-  SharedHandle<FileEntry> fileEntry_;
+  std::shared_ptr<FileEntry> fileEntry_;
 
-  SharedHandle<Segment> segment_;
+  std::shared_ptr<Segment> segment_;
 
   bool contentEncodingEnabled_;
 
@@ -74,15 +74,15 @@ private:
   // If true, metalink content types are sent in Accept header field.
   bool acceptMetalink_;
 
-  SharedHandle<CookieStorage> cookieStorage_;
+  std::shared_ptr<CookieStorage> cookieStorage_;
 
-  SharedHandle<AuthConfigFactory> authConfigFactory_;
+  std::shared_ptr<AuthConfigFactory> authConfigFactory_;
 
   const Option* option_;
 
-  SharedHandle<AuthConfig> authConfig_;
+  std::shared_ptr<AuthConfig> authConfig_;
 
-  SharedHandle<Request> proxyRequest_;
+  std::shared_ptr<Request> proxyRequest_;
 
   bool noCache_;
 
@@ -104,14 +104,14 @@ public:
   HttpRequest();
   ~HttpRequest();
 
-  const SharedHandle<Segment>& getSegment() const
+  const std::shared_ptr<Segment>& getSegment() const
   {
     return segment_;
   }
 
-  void setSegment(const SharedHandle<Segment>& segment);
+  void setSegment(const std::shared_ptr<Segment>& segment);
 
-  void setRequest(const SharedHandle<Request>& request);
+  void setRequest(const std::shared_ptr<Request>& request);
 
   int64_t getEntityLength() const;
 
@@ -143,7 +143,7 @@ public:
    */
   bool isRangeSatisfied(const Range& range) const;
 
-  const SharedHandle<Request>& getRequest() const
+  const std::shared_ptr<Request>& getRequest() const
   {
     return request_;
   }
@@ -185,21 +185,21 @@ public:
     acceptMetalink_ = f;
   }
 
-  void setCookieStorage(const SharedHandle<CookieStorage>& cookieStorage);
+  void setCookieStorage(const std::shared_ptr<CookieStorage>& cookieStorage);
 
-  const SharedHandle<CookieStorage>& getCookieStorage() const
+  const std::shared_ptr<CookieStorage>& getCookieStorage() const
   {
     return cookieStorage_;
   }
 
   void setAuthConfigFactory
-  (const SharedHandle<AuthConfigFactory>& factory, const Option* option);
+  (const std::shared_ptr<AuthConfigFactory>& factory, const Option* option);
 
   /*
    * To use proxy, pass proxy string to Request::setUri() and set it this
    * object.
    */
-  void setProxyRequest(const SharedHandle<Request>& proxyRequest);
+  void setProxyRequest(const std::shared_ptr<Request>& proxyRequest);
 
   /*
    * Returns true if non-Null proxy request is set by setProxyRequest().
@@ -213,11 +213,11 @@ public:
 
   // Returns AuthConfig used in the last invocation of
   // createRequest().
-  const SharedHandle<AuthConfig>& getAuthConfig() const;
+  const std::shared_ptr<AuthConfig>& getAuthConfig() const;
 
-  void setFileEntry(const SharedHandle<FileEntry>& fileEntry);
+  void setFileEntry(const std::shared_ptr<FileEntry>& fileEntry);
 
-  const SharedHandle<FileEntry>& getFileEntry() const
+  const std::shared_ptr<FileEntry>& getFileEntry() const
   {
     return fileEntry_;
   }
diff --git a/src/HttpRequestCommand.cc b/src/HttpRequestCommand.cc
index 971a861d..620dbf7d 100644
--- a/src/HttpRequestCommand.cc
+++ b/src/HttpRequestCommand.cc
@@ -64,12 +64,12 @@ namespace aria2 {
 
 HttpRequestCommand::HttpRequestCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
- const SharedHandle<HttpConnection>& httpConnection,
+ const std::shared_ptr<HttpConnection>& httpConnection,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& s)
+ const std::shared_ptr<SocketCore>& s)
   : AbstractCommand(cuid, req, fileEntry, requestGroup, e, s,
                     httpConnection->getSocketRecvBuffer()),
     httpConnection_(httpConnection)
@@ -82,19 +82,19 @@ HttpRequestCommand::HttpRequestCommand
 HttpRequestCommand::~HttpRequestCommand() {}
 
 namespace {
-SharedHandle<HttpRequest>
-createHttpRequest(const SharedHandle<Request>& req,
-                  const SharedHandle<FileEntry>& fileEntry,
-                  const SharedHandle<Segment>& segment,
+std::shared_ptr<HttpRequest>
+createHttpRequest(const std::shared_ptr<Request>& req,
+                  const std::shared_ptr<FileEntry>& fileEntry,
+                  const std::shared_ptr<Segment>& segment,
                   int64_t totalLength,
-                  const SharedHandle<Option>& option,
+                  const std::shared_ptr<Option>& option,
                   const RequestGroup* rg,
-                  const SharedHandle<CookieStorage>& cookieStorage,
-                  const SharedHandle<AuthConfigFactory>& authConfigFactory,
-                  const SharedHandle<Request>& proxyRequest,
+                  const std::shared_ptr<CookieStorage>& cookieStorage,
+                  const std::shared_ptr<AuthConfigFactory>& authConfigFactory,
+                  const std::shared_ptr<Request>& proxyRequest,
                   int64_t endOffset = 0)
 {
-  SharedHandle<HttpRequest> httpRequest(new HttpRequest());
+  std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
   httpRequest->setUserAgent(option->get(PREF_USER_AGENT));
   httpRequest->setRequest(req);
   httpRequest->setFileEntry(fileEntry);
@@ -136,10 +136,10 @@ bool HttpRequestCommand::executeInternal() {
     }
 #endif // ENABLE_SSL
     if(getSegments().empty()) {
-      SharedHandle<HttpRequest> httpRequest
+      std::shared_ptr<HttpRequest> httpRequest
         (createHttpRequest(getRequest(),
                            getFileEntry(),
-                           SharedHandle<Segment>(),
+                           std::shared_ptr<Segment>(),
                            getRequestGroup()->getTotalLength(),
                            getOption(),
                            getRequestGroup(),
@@ -172,10 +172,10 @@ bool HttpRequestCommand::executeInternal() {
       }
       httpConnection_->sendRequest(httpRequest);
     } else {
-      for(std::vector<SharedHandle<Segment> >::const_iterator itr =
+      for(std::vector<std::shared_ptr<Segment> >::const_iterator itr =
             getSegments().begin(), eoi = getSegments().end();
           itr != eoi; ++itr) {
-        const SharedHandle<Segment>& segment = *itr;
+        const std::shared_ptr<Segment>& segment = *itr;
         if(!httpConnection_->isIssued(segment)) {
           int64_t endOffset = 0;
           // FTP via HTTP proxy does not support end byte marker
@@ -188,7 +188,7 @@ bool HttpRequestCommand::executeInternal() {
                getFileEntry()->gtoloff
                (static_cast<int64_t>(segment->getSegmentLength())*nextIndex));
           }
-          SharedHandle<HttpRequest> httpRequest
+          std::shared_ptr<HttpRequest> httpRequest
             (createHttpRequest(getRequest(),
                                getFileEntry(),
                                segment,
@@ -225,7 +225,7 @@ bool HttpRequestCommand::executeInternal() {
 }
 
 void HttpRequestCommand::setProxyRequest
-(const SharedHandle<Request>& proxyRequest)
+(const std::shared_ptr<Request>& proxyRequest)
 {
   proxyRequest_ = proxyRequest;
 }
diff --git a/src/HttpRequestCommand.h b/src/HttpRequestCommand.h
index 8f6d37f9..f278a3c3 100644
--- a/src/HttpRequestCommand.h
+++ b/src/HttpRequestCommand.h
@@ -50,22 +50,22 @@ class SocketCore;
 // returns true.
 class HttpRequestCommand:public AbstractCommand {
 private:
-  SharedHandle<Request> proxyRequest_;
+  std::shared_ptr<Request> proxyRequest_;
 
-  SharedHandle<HttpConnection> httpConnection_;
+  std::shared_ptr<HttpConnection> httpConnection_;
 protected:
   virtual bool executeInternal();
 public:
   HttpRequestCommand(cuid_t cuid,
-                     const SharedHandle<Request>& req,
-                     const SharedHandle<FileEntry>& fileEntry,
+                     const std::shared_ptr<Request>& req,
+                     const std::shared_ptr<FileEntry>& fileEntry,
                      RequestGroup* requestGroup,
-                     const SharedHandle<HttpConnection>& httpConnection,
+                     const std::shared_ptr<HttpConnection>& httpConnection,
                      DownloadEngine* e,
-                     const SharedHandle<SocketCore>& s);
+                     const std::shared_ptr<SocketCore>& s);
   virtual ~HttpRequestCommand();
 
-  void setProxyRequest(const SharedHandle<Request>& proxyRequest);
+  void setProxyRequest(const std::shared_ptr<Request>& proxyRequest);
 };
 
 } // namespace aria2
diff --git a/src/HttpRequestConnectChain.h b/src/HttpRequestConnectChain.h
index d3a4f38f..ab6ef98e 100644
--- a/src/HttpRequestConnectChain.h
+++ b/src/HttpRequestConnectChain.h
@@ -49,9 +49,9 @@ struct HttpRequestConnectChain : public ControlChain<ConnectCommand*> {
   virtual ~HttpRequestConnectChain() {}
   virtual int run(ConnectCommand* t, DownloadEngine* e)
   {
-    SharedHandle<SocketRecvBuffer> socketRecvBuffer
+    std::shared_ptr<SocketRecvBuffer> socketRecvBuffer
       (new SocketRecvBuffer(t->getSocket()));
-    SharedHandle<HttpConnection> httpConnection
+    std::shared_ptr<HttpConnection> httpConnection
       (new HttpConnection(t->getCuid(), t->getSocket(), socketRecvBuffer));
     HttpRequestCommand* c = new HttpRequestCommand(t->getCuid(),
                                                    t->getRequest(),
diff --git a/src/HttpResponse.cc b/src/HttpResponse.cc
index cd7e821f..0d8642dc 100644
--- a/src/HttpResponse.cc
+++ b/src/HttpResponse.cc
@@ -191,9 +191,9 @@ const std::string& HttpResponse::getTransferEncoding() const
   return httpHeader_->find(HttpHeader::TRANSFER_ENCODING);
 }
 
-SharedHandle<StreamFilter> HttpResponse::getTransferEncodingStreamFilter() const
+std::shared_ptr<StreamFilter> HttpResponse::getTransferEncodingStreamFilter() const
 {
-  SharedHandle<StreamFilter> filter;
+  std::shared_ptr<StreamFilter> filter;
   // TODO Transfer-Encoding header field can contains multiple tokens. We should
   // parse the field and retrieve each token.
   if(isTransferEncodingSpecified()) {
@@ -214,9 +214,9 @@ const std::string& HttpResponse::getContentEncoding() const
   return httpHeader_->find(HttpHeader::CONTENT_ENCODING);
 }
 
-SharedHandle<StreamFilter> HttpResponse::getContentEncodingStreamFilter() const
+std::shared_ptr<StreamFilter> HttpResponse::getContentEncodingStreamFilter() const
 {
-  SharedHandle<StreamFilter> filter;
+  std::shared_ptr<StreamFilter> filter;
 #ifdef HAVE_ZLIB
   if(util::strieq(getContentEncoding(), "gzip") ||
      util::strieq(getContentEncoding(), "deflate")) {
@@ -256,12 +256,12 @@ std::string HttpResponse::getContentType() const
   }
 }
 
-void HttpResponse::setHttpHeader(const SharedHandle<HttpHeader>& httpHeader)
+void HttpResponse::setHttpHeader(const std::shared_ptr<HttpHeader>& httpHeader)
 {
   httpHeader_ = httpHeader;
 }
 
-void HttpResponse::setHttpRequest(const SharedHandle<HttpRequest>& httpRequest)
+void HttpResponse::setHttpRequest(const std::shared_ptr<HttpRequest>& httpRequest)
 {
   httpRequest_ = httpRequest;
 }
@@ -344,7 +344,7 @@ bool parseMetalinkHttpLink(MetalinkHttpEntry& result, const std::string& s)
 // Link header field is defined by http://tools.ietf.org/html/rfc5988.
 void HttpResponse::getMetalinKHttpEntries
 (std::vector<MetalinkHttpEntry>& result,
- const SharedHandle<Option>& option) const
+ const std::shared_ptr<Option>& option) const
 {
   std::pair<std::multimap<int, std::string>::const_iterator,
             std::multimap<int, std::string>::const_iterator> p =
diff --git a/src/HttpResponse.h b/src/HttpResponse.h
index f23a92eb..22ec13c1 100644
--- a/src/HttpResponse.h
+++ b/src/HttpResponse.h
@@ -39,8 +39,8 @@
 
 #include <stdint.h>
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimeA2.h"
 #include "Command.h"
 
@@ -56,8 +56,8 @@ class Checksum;
 class HttpResponse {
 private:
   cuid_t cuid_;
-  SharedHandle<HttpRequest> httpRequest_;
-  SharedHandle<HttpHeader> httpHeader_;
+  std::shared_ptr<HttpRequest> httpRequest_;
+  std::shared_ptr<HttpHeader> httpHeader_;
 public:
   HttpResponse();
 
@@ -88,13 +88,13 @@ public:
 
   const std::string& getTransferEncoding() const;
 
-  SharedHandle<StreamFilter> getTransferEncodingStreamFilter() const;
+  std::shared_ptr<StreamFilter> getTransferEncodingStreamFilter() const;
 
   bool isContentEncodingSpecified() const;
 
   const std::string& getContentEncoding() const;
 
-  SharedHandle<StreamFilter> getContentEncodingStreamFilter() const;
+  std::shared_ptr<StreamFilter> getContentEncodingStreamFilter() const;
 
   int64_t getContentLength() const;
 
@@ -103,18 +103,18 @@ public:
   // Returns type "/" subtype. The parameter is removed.
   std::string getContentType() const;
 
-  void setHttpHeader(const SharedHandle<HttpHeader>& httpHeader);
+  void setHttpHeader(const std::shared_ptr<HttpHeader>& httpHeader);
 
-  const SharedHandle<HttpHeader>& getHttpHeader() const
+  const std::shared_ptr<HttpHeader>& getHttpHeader() const
   {
     return httpHeader_;
   }
 
   int getStatusCode() const;
 
-  void setHttpRequest(const SharedHandle<HttpRequest>& httpRequest);
+  void setHttpRequest(const std::shared_ptr<HttpRequest>& httpRequest);
 
-  const SharedHandle<HttpRequest>& getHttpRequest() const
+  const std::shared_ptr<HttpRequest>& getHttpRequest() const
   {
     return httpRequest_;
   }
@@ -130,7 +130,7 @@ public:
 
   void getMetalinKHttpEntries
   (std::vector<MetalinkHttpEntry>& result,
-   const SharedHandle<Option>& option) const;
+   const std::shared_ptr<Option>& option) const;
 #ifdef ENABLE_MESSAGE_DIGEST
   // Returns all digests specified in Digest header field.  Sort
   // strong algorithm first. Strength is defined in MessageDigest. If
diff --git a/src/HttpResponseCommand.cc b/src/HttpResponseCommand.cc
index c04e5818..872f401a 100644
--- a/src/HttpResponseCommand.cc
+++ b/src/HttpResponseCommand.cc
@@ -84,11 +84,11 @@
 namespace aria2 {
 
 namespace {
-SharedHandle<StreamFilter> getTransferEncodingStreamFilter
-(const SharedHandle<HttpResponse>& httpResponse,
- const SharedHandle<StreamFilter>& delegate = SharedHandle<StreamFilter>())
+std::shared_ptr<StreamFilter> getTransferEncodingStreamFilter
+(const std::shared_ptr<HttpResponse>& httpResponse,
+ const std::shared_ptr<StreamFilter>& delegate = std::shared_ptr<StreamFilter>())
 {
-  SharedHandle<StreamFilter> filter;
+  std::shared_ptr<StreamFilter> filter;
   if(httpResponse->isTransferEncodingSpecified()) {
     filter = httpResponse->getTransferEncodingStreamFilter();
     if(!filter) {
@@ -107,11 +107,11 @@ SharedHandle<StreamFilter> getTransferEncodingStreamFilter
 } // namespace
 
 namespace {
-SharedHandle<StreamFilter> getContentEncodingStreamFilter
-(const SharedHandle<HttpResponse>& httpResponse,
- const SharedHandle<StreamFilter>& delegate = SharedHandle<StreamFilter>())
+std::shared_ptr<StreamFilter> getContentEncodingStreamFilter
+(const std::shared_ptr<HttpResponse>& httpResponse,
+ const std::shared_ptr<StreamFilter>& delegate = std::shared_ptr<StreamFilter>())
 {
-  SharedHandle<StreamFilter> filter;
+  std::shared_ptr<StreamFilter> filter;
   if(httpResponse->isContentEncodingSpecified()) {
     filter = httpResponse->getContentEncodingStreamFilter();
     if(!filter) {
@@ -134,12 +134,12 @@ SharedHandle<StreamFilter> getContentEncodingStreamFilter
 
 HttpResponseCommand::HttpResponseCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
- const SharedHandle<HttpConnection>& httpConnection,
+ const std::shared_ptr<HttpConnection>& httpConnection,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& s)
+ const std::shared_ptr<SocketCore>& s)
   : AbstractCommand(cuid, req, fileEntry, requestGroup, e, s,
                     httpConnection->getSocketRecvBuffer()),
     httpConnection_(httpConnection)
@@ -151,8 +151,8 @@ HttpResponseCommand::~HttpResponseCommand() {}
 
 bool HttpResponseCommand::executeInternal()
 {
-  SharedHandle<HttpRequest> httpRequest =httpConnection_->getFirstHttpRequest();
-  SharedHandle<HttpResponse> httpResponse = httpConnection_->receiveResponse();
+  std::shared_ptr<HttpRequest> httpRequest =httpConnection_->getFirstHttpRequest();
+  std::shared_ptr<HttpResponse> httpResponse = httpConnection_->receiveResponse();
   if(!httpResponse) {
     // The server has not responded to our request yet.
     // For socket->wantRead() == true, setReadCheckSocket(socket) is already
@@ -165,7 +165,7 @@ bool HttpResponseCommand::executeInternal()
   httpResponse->validateResponse();
   httpResponse->retrieveCookie();
 
-  SharedHandle<HttpHeader> httpHeader = httpResponse->getHttpHeader();
+  std::shared_ptr<HttpHeader> httpHeader = httpResponse->getHttpHeader();
   // Disable persistent connection if:
   //   Connection: close is received or the remote server is not HTTP/1.1.
   // We don't care whether non-HTTP/1.1 server returns Connection: keep-alive.
@@ -332,7 +332,7 @@ void HttpResponseCommand::updateLastModifiedTime(const Time& lastModified)
 }
 
 bool HttpResponseCommand::shouldInflateContentEncoding
-(const SharedHandle<HttpResponse>& httpResponse)
+(const std::shared_ptr<HttpResponse>& httpResponse)
 {
   // Basically, on the fly inflation cannot be made with segment
   // download, because in each segment we don't know where the date
@@ -347,12 +347,12 @@ bool HttpResponseCommand::shouldInflateContentEncoding
 }
 
 bool HttpResponseCommand::handleDefaultEncoding
-(const SharedHandle<HttpResponse>& httpResponse)
+(const std::shared_ptr<HttpResponse>& httpResponse)
 {
-  SharedHandle<HttpRequest> httpRequest = httpResponse->getHttpRequest();
-  SharedHandle<BtProgressInfoFile> progressInfoFile
+  std::shared_ptr<HttpRequest> httpRequest = httpResponse->getHttpRequest();
+  std::shared_ptr<BtProgressInfoFile> progressInfoFile
     (new DefaultBtProgressInfoFile
-     (getDownloadContext(), SharedHandle<PieceStorage>(), getOption().get()));
+     (getDownloadContext(), std::shared_ptr<PieceStorage>(), getOption().get()));
   getRequestGroup()->adjustFilename(progressInfoFile);
   getRequestGroup()->initPieceStorage();
 
@@ -361,7 +361,7 @@ bool HttpResponseCommand::handleDefaultEncoding
     return true;
   }
 
-  SharedHandle<CheckIntegrityEntry> checkEntry =
+  std::shared_ptr<CheckIntegrityEntry> checkEntry =
     getRequestGroup()->createCheckIntegrityEntry();
   if(!checkEntry) {
     return true;
@@ -370,7 +370,7 @@ bool HttpResponseCommand::handleDefaultEncoding
   // We have to make sure that command that has Request object must
   // have segment after PieceStorage is initialized. See
   // AbstractCommand::execute()
-  SharedHandle<Segment> segment =
+  std::shared_ptr<Segment> segment =
     getSegmentMan()->getSegmentWithIndex(getCuid(), 0);
   // pipelining requires implicit range specified. But the request for
   // this response most likely dones't contains range header. This means
@@ -403,9 +403,9 @@ bool HttpResponseCommand::handleDefaultEncoding
 }
 
 bool HttpResponseCommand::handleOtherEncoding
-(const SharedHandle<HttpResponse>& httpResponse) {
+(const std::shared_ptr<HttpResponse>& httpResponse) {
   // We assume that RequestGroup::getTotalLength() == 0 here
-  SharedHandle<HttpRequest> httpRequest = httpResponse->getHttpRequest();
+  std::shared_ptr<HttpRequest> httpRequest = httpResponse->getHttpRequest();
 
   if(getOption()->getAsBool(PREF_DRY_RUN)) {
     getRequestGroup()->initPieceStorage();
@@ -422,7 +422,7 @@ bool HttpResponseCommand::handleOtherEncoding
   // In this context, knowsTotalLength() is true only when the file is
   // really zero-length.
 
-  SharedHandle<StreamFilter> streamFilter =
+  std::shared_ptr<StreamFilter> streamFilter =
     getTransferEncodingStreamFilter
     (httpResponse,
      getContentEncodingStreamFilter(httpResponse));
@@ -441,7 +441,7 @@ bool HttpResponseCommand::handleOtherEncoding
     // See also FtpNegotiationCommand::onFileSizeDetermined()
     if(getDownloadContext()->isChecksumVerificationNeeded()) {
       A2_LOG_DEBUG("Zero length file exists. Verify checksum.");
-      SharedHandle<ChecksumCheckIntegrityEntry> entry
+      std::shared_ptr<ChecksumCheckIntegrityEntry> entry
         (new ChecksumCheckIntegrityEntry(getRequestGroup()));
       entry->initValidator();
       getPieceStorage()->getDiskAdaptor()->openExistingFile();
@@ -475,7 +475,7 @@ bool HttpResponseCommand::handleOtherEncoding
 #ifdef ENABLE_MESSAGE_DIGEST
     if(getDownloadContext()->isChecksumVerificationNeeded()) {
       A2_LOG_DEBUG("Verify checksum for zero-length file");
-      SharedHandle<ChecksumCheckIntegrityEntry> entry
+      std::shared_ptr<ChecksumCheckIntegrityEntry> entry
         (new ChecksumCheckIntegrityEntry(getRequestGroup()));
       entry->initValidator();
       getDownloadEngine()->getCheckIntegrityMan()->pushEntry(entry);
@@ -498,9 +498,9 @@ bool HttpResponseCommand::handleOtherEncoding
 }
 
 bool HttpResponseCommand::skipResponseBody
-(const SharedHandle<HttpResponse>& httpResponse)
+(const std::shared_ptr<HttpResponse>& httpResponse)
 {
-  SharedHandle<StreamFilter> filter =
+  std::shared_ptr<StreamFilter> filter =
     getTransferEncodingStreamFilter(httpResponse);
   // We don't use Content-Encoding here because this response body is just
   // thrown away.
@@ -528,10 +528,10 @@ bool HttpResponseCommand::skipResponseBody
 
 namespace {
 bool decideFileAllocation
-(const SharedHandle<StreamFilter>& filter)
+(const std::shared_ptr<StreamFilter>& filter)
 {
 #ifdef HAVE_ZLIB
-  for(SharedHandle<StreamFilter> f = filter; f; f = f->getDelegate()){
+  for(std::shared_ptr<StreamFilter> f = filter; f; f = f->getDelegate()){
     // Since the compressed file's length are returned in the response header
     // and the decompressed file size is unknown at this point, disable file
     // allocation here.
@@ -545,8 +545,8 @@ bool decideFileAllocation
 } // namespace
 
 HttpDownloadCommand* HttpResponseCommand::createHttpDownloadCommand
-(const SharedHandle<HttpResponse>& httpResponse,
- const SharedHandle<StreamFilter>& filter)
+(const std::shared_ptr<HttpResponse>& httpResponse,
+ const std::shared_ptr<StreamFilter>& filter)
 {
 
   HttpDownloadCommand* command =
@@ -585,7 +585,7 @@ void HttpResponseCommand::onDryRunFileFound()
 
 #ifdef ENABLE_MESSAGE_DIGEST
 bool HttpResponseCommand::checkChecksum
-(const SharedHandle<DownloadContext>& dctx,
+(const std::shared_ptr<DownloadContext>& dctx,
  const Checksum& checksum)
 {
   if(dctx->getHashType() == checksum.getHashType()) {
diff --git a/src/HttpResponseCommand.h b/src/HttpResponseCommand.h
index 6c691e0e..8a947d5d 100644
--- a/src/HttpResponseCommand.h
+++ b/src/HttpResponseCommand.h
@@ -61,16 +61,16 @@ class Checksum;
 // HttpSkipResponseCommand.
 class HttpResponseCommand : public AbstractCommand {
 private:
-  SharedHandle<HttpConnection> httpConnection_;
+  std::shared_ptr<HttpConnection> httpConnection_;
 
-  bool handleDefaultEncoding(const SharedHandle<HttpResponse>& httpResponse);
-  bool handleOtherEncoding(const SharedHandle<HttpResponse>& httpResponse);
-  bool skipResponseBody(const SharedHandle<HttpResponse>& httpResponse);
+  bool handleDefaultEncoding(const std::shared_ptr<HttpResponse>& httpResponse);
+  bool handleOtherEncoding(const std::shared_ptr<HttpResponse>& httpResponse);
+  bool skipResponseBody(const std::shared_ptr<HttpResponse>& httpResponse);
 
   HttpDownloadCommand*
   createHttpDownloadCommand
-  (const SharedHandle<HttpResponse>& httpResponse,
-   const SharedHandle<StreamFilter>& streamFilter);
+  (const std::shared_ptr<HttpResponse>& httpResponse,
+   const std::shared_ptr<StreamFilter>& streamFilter);
 
   void updateLastModifiedTime(const Time& lastModified);
 
@@ -82,23 +82,23 @@ private:
   // value.  If they have same hash type but different hash value,
   // throws exception.  Otherwise returns false.
   bool checkChecksum
-  (const SharedHandle<DownloadContext>& dctx,
+  (const std::shared_ptr<DownloadContext>& dctx,
    const Checksum& checksum);
 #endif // ENABLE_MESSAGE_DIGEST
 protected:
   bool executeInternal();
 
   bool shouldInflateContentEncoding
-  (const SharedHandle<HttpResponse>& httpResponse);
+  (const std::shared_ptr<HttpResponse>& httpResponse);
 
 public:
   HttpResponseCommand(cuid_t cuid,
-                      const SharedHandle<Request>& req,
-                      const SharedHandle<FileEntry>& fileEntry,
+                      const std::shared_ptr<Request>& req,
+                      const std::shared_ptr<FileEntry>& fileEntry,
                       RequestGroup* requestGroup,
-                      const SharedHandle<HttpConnection>& httpConnection,
+                      const std::shared_ptr<HttpConnection>& httpConnection,
                       DownloadEngine* e,
-                      const SharedHandle<SocketCore>& s);
+                      const std::shared_ptr<SocketCore>& s);
   ~HttpResponseCommand();
 };
 
diff --git a/src/HttpServer.cc b/src/HttpServer.cc
index 194a8b89..f314ee1e 100644
--- a/src/HttpServer.cc
+++ b/src/HttpServer.cc
@@ -57,7 +57,7 @@
 
 namespace aria2 {
 
-HttpServer::HttpServer(const SharedHandle<SocketCore>& socket)
+HttpServer::HttpServer(const std::shared_ptr<SocketCore>& socket)
  : socket_(socket),
    socketRecvBuffer_(new SocketRecvBuffer(socket_)),
    socketBuffer_(socket),
@@ -126,7 +126,7 @@ const char* getStatusString(int status)
 }
 } // namespace
 
-SharedHandle<HttpHeader> HttpServer::receiveRequest()
+std::shared_ptr<HttpHeader> HttpServer::receiveRequest()
 {
   if(socketRecvBuffer_->bufferEmpty()) {
     if(socketRecvBuffer_->recv() == 0 &&
@@ -134,7 +134,7 @@ SharedHandle<HttpHeader> HttpServer::receiveRequest()
       throw DL_ABORT_EX(EX_EOF_FROM_PEER);
     }
   }
-  SharedHandle<HttpHeader> header;
+  std::shared_ptr<HttpHeader> header;
   if(headerProcessor_->parse(socketRecvBuffer_->getBuffer(),
                              socketRecvBuffer_->getBufferLength())) {
     header = headerProcessor_->getResult();
diff --git a/src/HttpServer.h b/src/HttpServer.h
index b2ef76d4..8f07412a 100644
--- a/src/HttpServer.h
+++ b/src/HttpServer.h
@@ -40,8 +40,8 @@
 #include <string>
 #include <sstream>
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "SocketBuffer.h"
 
 namespace aria2 {
@@ -64,17 +64,17 @@ enum RequestType {
 // intended to be a generic HTTP server.
 class HttpServer {
 private:
-  SharedHandle<SocketCore> socket_;
-  SharedHandle<SocketRecvBuffer> socketRecvBuffer_;
+  std::shared_ptr<SocketCore> socket_;
+  std::shared_ptr<SocketRecvBuffer> socketRecvBuffer_;
   SocketBuffer socketBuffer_;
-  SharedHandle<HttpHeaderProcessor> headerProcessor_;
-  SharedHandle<HttpHeader> lastRequestHeader_;
+  std::shared_ptr<HttpHeaderProcessor> headerProcessor_;
+  std::shared_ptr<HttpHeader> lastRequestHeader_;
   int64_t lastContentLength_;
   // How many bytes are consumed. The total number of bytes is
   // lastContentLength_.
   int64_t bodyConsumed_;
   RequestType reqType_;
-  SharedHandle<DiskWriter> lastBody_;
+  std::shared_ptr<DiskWriter> lastBody_;
   bool keepAlive_;
   bool gzip_;
   std::string username_;
@@ -83,11 +83,11 @@ private:
   std::string allowOrigin_;
   bool secure_;
 public:
-  HttpServer(const SharedHandle<SocketCore>& socket);
+  HttpServer(const std::shared_ptr<SocketCore>& socket);
 
   ~HttpServer();
 
-  SharedHandle<HttpHeader> receiveRequest();
+  std::shared_ptr<HttpHeader> receiveRequest();
 
   bool receiveBody();
 
@@ -101,7 +101,7 @@ public:
 
   std::string createQuery() const;
 
-  const SharedHandle<DiskWriter>& getBody() const
+  const std::shared_ptr<DiskWriter>& getBody() const
   {
     return lastBody_;
   }
@@ -154,7 +154,7 @@ public:
 
   int64_t getContentLength() const { return lastContentLength_; }
 
-  const SharedHandle<SocketRecvBuffer>& getSocketRecvBuffer() const
+  const std::shared_ptr<SocketRecvBuffer>& getSocketRecvBuffer() const
   {
     return socketRecvBuffer_;
   }
@@ -169,12 +169,12 @@ public:
     allowOrigin_ = allowOrigin;
   }
 
-  const SharedHandle<SocketCore>& getSocket() const
+  const std::shared_ptr<SocketCore>& getSocket() const
   {
     return socket_;
   }
 
-  const SharedHandle<HttpHeader>& getRequestHeader() const
+  const std::shared_ptr<HttpHeader>& getRequestHeader() const
   {
     return lastRequestHeader_;
   }
diff --git a/src/HttpServerBodyCommand.cc b/src/HttpServerBodyCommand.cc
index 23230d00..a860e90d 100644
--- a/src/HttpServerBodyCommand.cc
+++ b/src/HttpServerBodyCommand.cc
@@ -68,9 +68,9 @@ namespace aria2 {
 
 HttpServerBodyCommand::HttpServerBodyCommand
 (cuid_t cuid,
- const SharedHandle<HttpServer>& httpServer,
+ const std::shared_ptr<HttpServer>& httpServer,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& socket)
+ const std::shared_ptr<SocketCore>& socket)
   : Command(cuid),
     e_(e),
     socket_(socket),
@@ -184,7 +184,7 @@ bool HttpServerBodyCommand::execute()
         if(httpServer_->getMethod() == "OPTIONS") {
           // Response to Preflight Request.
           // See http://www.w3.org/TR/cors/
-          const SharedHandle<HttpHeader>& header =
+          const std::shared_ptr<HttpHeader>& header =
             httpServer_->getRequestHeader();
           std::string accessControlHeaders;
           if(!header->find(HttpHeader::ORIGIN).empty() &&
@@ -211,8 +211,8 @@ bool HttpServerBodyCommand::execute()
         switch(httpServer_->getRequestType()) {
         case RPC_TYPE_XML: {
 #ifdef ENABLE_XML_RPC
-          SharedHandle<rpc::XmlRpcDiskWriter> dw =
-            static_pointer_cast<rpc::XmlRpcDiskWriter>(httpServer_->getBody());
+          auto dw = std::static_pointer_cast<rpc::XmlRpcDiskWriter>
+            (httpServer_->getBody());
           int error;
           error = dw->finalize();
           rpc::RpcRequest req;
@@ -228,7 +228,7 @@ bool HttpServerBodyCommand::execute()
             addHttpServerResponseCommand();
             return true;
           }
-          SharedHandle<rpc::RpcMethod> method =
+          std::shared_ptr<rpc::RpcMethod> method =
             rpc::RpcMethodFactory::create(req.methodName);
           A2_LOG_INFO(fmt("Executing RPC method %s", req.methodName.c_str()));
           rpc::RpcResponse res = method->execute(req, e_);
@@ -245,7 +245,7 @@ bool HttpServerBodyCommand::execute()
         case RPC_TYPE_JSON:
         case RPC_TYPE_JSONP: {
           std::string callback;
-          SharedHandle<ValueBase> json;
+          std::shared_ptr<ValueBase> json;
           ssize_t error = 0;
           if(httpServer_->getRequestType() == RPC_TYPE_JSONP) {
             json::JsonGetParam param = json::decodeGetParams(query);
@@ -256,8 +256,8 @@ bool HttpServerBodyCommand::execute()
                param.request.size(),
                error);
           } else {
-            SharedHandle<json::JsonDiskWriter> dw =
-              static_pointer_cast<json::JsonDiskWriter>(httpServer_->getBody());
+            auto dw = std::static_pointer_cast<json::JsonDiskWriter>
+              (httpServer_->getBody());
             error = dw->finalize();
             if(error == 0) {
               json = dw->getResult();
diff --git a/src/HttpServerBodyCommand.h b/src/HttpServerBodyCommand.h
index 46c86919..34a1119d 100644
--- a/src/HttpServerBodyCommand.h
+++ b/src/HttpServerBodyCommand.h
@@ -36,7 +36,9 @@
 #define D_HTTP_SERVER_BODY_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "TimerA2.h"
 #include "ValueBase.h"
 #include "RpcResponse.h"
@@ -50,8 +52,8 @@ class HttpServer;
 class HttpServerBodyCommand : public Command {
 private:
   DownloadEngine* e_;
-  SharedHandle<SocketCore> socket_;
-  SharedHandle<HttpServer> httpServer_;
+  std::shared_ptr<SocketCore> socket_;
+  std::shared_ptr<HttpServer> httpServer_;
   Timer timeoutTimer_;
   bool writeCheck_;
 
@@ -59,7 +61,7 @@ private:
   (const std::string& httpStatus,
    int code,
    const std::string& message,
-   const SharedHandle<ValueBase>& id,
+   const std::shared_ptr<ValueBase>& id,
    const std::string& callback);
   void sendJsonRpcResponse
   (const rpc::RpcResponse& res,
@@ -71,9 +73,9 @@ private:
   void updateWriteCheck();
 public:
   HttpServerBodyCommand(cuid_t cuid,
-                        const SharedHandle<HttpServer>& httpServer,
+                        const std::shared_ptr<HttpServer>& httpServer,
                         DownloadEngine* e,
-                        const SharedHandle<SocketCore>& socket);
+                        const std::shared_ptr<SocketCore>& socket);
 
   virtual ~HttpServerBodyCommand();
 
diff --git a/src/HttpServerCommand.cc b/src/HttpServerCommand.cc
index 848df1bf..257ab474 100644
--- a/src/HttpServerCommand.cc
+++ b/src/HttpServerCommand.cc
@@ -64,7 +64,7 @@ namespace aria2 {
 HttpServerCommand::HttpServerCommand
 (cuid_t cuid,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& socket,
+ const std::shared_ptr<SocketCore>& socket,
  bool secure)
   : Command(cuid),
     e_(e),
@@ -90,9 +90,9 @@ HttpServerCommand::HttpServerCommand
 
 HttpServerCommand::HttpServerCommand
 (cuid_t cuid,
- const SharedHandle<HttpServer>& httpServer,
+ const std::shared_ptr<HttpServer>& httpServer,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& socket)
+ const std::shared_ptr<SocketCore>& socket)
   : Command(cuid),
     e_(e),
     socket_(socket),
@@ -137,7 +137,7 @@ std::string createWebSocketServerKey(const std::string& clientKey)
 } // namespace
 
 namespace {
-int websocketHandshake(const SharedHandle<HttpHeader>& header)
+int websocketHandshake(const std::shared_ptr<HttpHeader>& header)
 {
   if(header->getMethod() != "GET" ||
      header->find(HttpHeader::SEC_WEBSOCKET_KEY).empty()) {
@@ -190,7 +190,7 @@ bool HttpServerCommand::execute()
       }
 #endif // ENABLE_SSL
 
-      SharedHandle<HttpHeader> header;
+      std::shared_ptr<HttpHeader> header;
       header = httpServer_->receiveRequest();
       if(!header) {
         updateWriteCheck();
diff --git a/src/HttpServerCommand.h b/src/HttpServerCommand.h
index e8bf4cd0..aa47f943 100644
--- a/src/HttpServerCommand.h
+++ b/src/HttpServerCommand.h
@@ -36,7 +36,9 @@
 #define D_HTTP_SERVER_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "TimerA2.h"
 
 namespace aria2 {
@@ -48,8 +50,8 @@ class HttpServer;
 class HttpServerCommand : public Command {
 private:
   DownloadEngine* e_;
-  SharedHandle<SocketCore> socket_;
-  SharedHandle<HttpServer> httpServer_;
+  std::shared_ptr<SocketCore> socket_;
+  std::shared_ptr<HttpServer> httpServer_;
   Timer timeoutTimer_;
   bool writeCheck_;
 
@@ -57,13 +59,13 @@ private:
   void updateWriteCheck();
 public:
   HttpServerCommand(cuid_t cuid, DownloadEngine* e,
-                    const SharedHandle<SocketCore>& socket,
+                    const std::shared_ptr<SocketCore>& socket,
                     bool secure);
 
   HttpServerCommand(cuid_t cuid,
-                    const SharedHandle<HttpServer>& httpServer,
+                    const std::shared_ptr<HttpServer>& httpServer,
                     DownloadEngine* e,
-                    const SharedHandle<SocketCore>& socket);
+                    const std::shared_ptr<SocketCore>& socket);
 
   virtual ~HttpServerCommand();
 
diff --git a/src/HttpServerResponseCommand.cc b/src/HttpServerResponseCommand.cc
index 473afd84..a2aa1555 100644
--- a/src/HttpServerResponseCommand.cc
+++ b/src/HttpServerResponseCommand.cc
@@ -46,9 +46,9 @@ namespace aria2 {
 
 HttpServerResponseCommand::HttpServerResponseCommand
 (cuid_t cuid,
- const SharedHandle<HttpServer>& httpServer,
+ const std::shared_ptr<HttpServer>& httpServer,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& socket)
+ const std::shared_ptr<SocketCore>& socket)
   : AbstractHttpServerResponseCommand(cuid, httpServer, e, socket)
 {}
 
@@ -56,7 +56,7 @@ HttpServerResponseCommand::~HttpServerResponseCommand()
 {}
 
 void HttpServerResponseCommand::afterSend
-(const SharedHandle<HttpServer>& httpServer,
+(const std::shared_ptr<HttpServer>& httpServer,
  DownloadEngine* e)
 {
   if(httpServer->supportsPersistentConnection()) {
diff --git a/src/HttpServerResponseCommand.h b/src/HttpServerResponseCommand.h
index 2df208e0..271c26a5 100644
--- a/src/HttpServerResponseCommand.h
+++ b/src/HttpServerResponseCommand.h
@@ -41,13 +41,13 @@ namespace aria2 {
 
 class HttpServerResponseCommand : public AbstractHttpServerResponseCommand {
 protected:
-  virtual void afterSend(const SharedHandle<HttpServer>& httpServer,
+  virtual void afterSend(const std::shared_ptr<HttpServer>& httpServer,
                          DownloadEngine* e);
 public:
   HttpServerResponseCommand(cuid_t cuid,
-                            const SharedHandle<HttpServer>& httpServer,
+                            const std::shared_ptr<HttpServer>& httpServer,
                             DownloadEngine* e,
-                            const SharedHandle<SocketCore>& socket);
+                            const std::shared_ptr<SocketCore>& socket);
 
   virtual ~HttpServerResponseCommand();
 };
diff --git a/src/HttpSkipResponseCommand.cc b/src/HttpSkipResponseCommand.cc
index 75d65637..0308c0ab 100644
--- a/src/HttpSkipResponseCommand.cc
+++ b/src/HttpSkipResponseCommand.cc
@@ -65,13 +65,13 @@ namespace aria2 {
 
 HttpSkipResponseCommand::HttpSkipResponseCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
- const SharedHandle<HttpConnection>& httpConnection,
- const SharedHandle<HttpResponse>& httpResponse,
+ const std::shared_ptr<HttpConnection>& httpConnection,
+ const std::shared_ptr<HttpResponse>& httpResponse,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& s)
+ const std::shared_ptr<SocketCore>& s)
   : AbstractCommand(cuid, req, fileEntry, requestGroup, e, s,
                     httpConnection->getSocketRecvBuffer()),
     httpConnection_(httpConnection),
@@ -87,7 +87,7 @@ HttpSkipResponseCommand::HttpSkipResponseCommand
 HttpSkipResponseCommand::~HttpSkipResponseCommand() {}
 
 void HttpSkipResponseCommand::installStreamFilter
-(const SharedHandle<StreamFilter>& streamFilter)
+(const std::shared_ptr<StreamFilter>& streamFilter)
 {
   if(!streamFilter) {
     return;
@@ -132,8 +132,8 @@ bool HttpSkipResponseCommand::executeInternal()
       } else {
         // receivedBytes_ is not updated if transferEncoding is set.
         // The return value is safely ignored here.
-        streamFilter_->transform(SharedHandle<BinaryStream>(),
-                                 SharedHandle<Segment>(),
+        streamFilter_->transform(std::shared_ptr<BinaryStream>(),
+                                 std::shared_ptr<Segment>(),
                                  getSocketRecvBuffer()->getBuffer(),
                                  getSocketRecvBuffer()->getBufferLength());
         bufSize = streamFilter_->getBytesProcessed();
diff --git a/src/HttpSkipResponseCommand.h b/src/HttpSkipResponseCommand.h
index efbdc2a8..d30e1889 100644
--- a/src/HttpSkipResponseCommand.h
+++ b/src/HttpSkipResponseCommand.h
@@ -45,11 +45,11 @@ class StreamFilter;
 
 class HttpSkipResponseCommand : public AbstractCommand {
 private:
-  SharedHandle<HttpConnection> httpConnection_;
+  std::shared_ptr<HttpConnection> httpConnection_;
 
-  SharedHandle<HttpResponse> httpResponse_;
+  std::shared_ptr<HttpResponse> httpResponse_;
 
-  SharedHandle<StreamFilter> streamFilter_;
+  std::shared_ptr<StreamFilter> streamFilter_;
 
   bool sinkFilterOnly_;
 
@@ -65,17 +65,17 @@ protected:
 public:
   HttpSkipResponseCommand
   (cuid_t cuid,
-   const SharedHandle<Request>& req,
-   const SharedHandle<FileEntry>& fileEntry,
+   const std::shared_ptr<Request>& req,
+   const std::shared_ptr<FileEntry>& fileEntry,
    RequestGroup* requestGroup,
-   const SharedHandle<HttpConnection>& httpConnection,
-   const SharedHandle<HttpResponse>& httpResponse,
+   const std::shared_ptr<HttpConnection>& httpConnection,
+   const std::shared_ptr<HttpResponse>& httpResponse,
    DownloadEngine* e,
-   const SharedHandle<SocketCore>& s);
+   const std::shared_ptr<SocketCore>& s);
 
   virtual ~HttpSkipResponseCommand();
 
-  void installStreamFilter(const SharedHandle<StreamFilter>& streamFilter);
+  void installStreamFilter(const std::shared_ptr<StreamFilter>& streamFilter);
 
   void disableSocketCheck();
 };
diff --git a/src/InitiateConnectionCommand.cc b/src/InitiateConnectionCommand.cc
index 98cae3b4..069a5a8f 100644
--- a/src/InitiateConnectionCommand.cc
+++ b/src/InitiateConnectionCommand.cc
@@ -58,8 +58,8 @@ namespace aria2 {
 
 InitiateConnectionCommand::InitiateConnectionCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e)
   : AbstractCommand(cuid, req, fileEntry, requestGroup, e)
@@ -76,7 +76,7 @@ InitiateConnectionCommand::~InitiateConnectionCommand() {}
 bool InitiateConnectionCommand::executeInternal() {
   std::string hostname;
   uint16_t port;
-  SharedHandle<Request> proxyRequest = createProxyRequest();
+  std::shared_ptr<Request> proxyRequest = createProxyRequest();
   if(!proxyRequest) {
     hostname = getRequest()->getHost();
     port = getRequest()->getPort();
@@ -120,23 +120,23 @@ bool InitiateConnectionCommand::executeInternal() {
 }
 
 void InitiateConnectionCommand::setConnectedAddrInfo
-(const SharedHandle<Request>& req,
+(const std::shared_ptr<Request>& req,
  const std::string& hostname,
- const SharedHandle<SocketCore>& socket)
+ const std::shared_ptr<SocketCore>& socket)
 {
   std::pair<std::string, uint16_t> peerAddr;
   socket->getPeerInfo(peerAddr);
   req->setConnectedAddrInfo(hostname, peerAddr.first, peerAddr.second);
 }
 
-SharedHandle<BackupConnectInfo>
+std::shared_ptr<BackupConnectInfo>
 InitiateConnectionCommand::createBackupIPv4ConnectCommand
 (const std::string& hostname, const std::string& ipaddr, uint16_t port,
  Command* mainCommand)
 {
   // Prepare IPv4 backup connection attemp in "Happy Eyeballs"
   // fashion.
-  SharedHandle<BackupConnectInfo> info;
+  std::shared_ptr<BackupConnectInfo> info;
   char buf[sizeof(in6_addr)];
   if(inetPton(AF_INET6, ipaddr.c_str(), &buf) == -1) {
     return info;
@@ -152,7 +152,7 @@ InitiateConnectionCommand::createBackupIPv4ConnectCommand
       BackupIPv4ConnectCommand* command = new BackupIPv4ConnectCommand
         (getDownloadEngine()->newCUID(), *i, port, info, mainCommand,
          getRequestGroup(), getDownloadEngine());
-      A2_LOG_INFO(fmt("Issue backup connection command CUID#%"PRId64
+      A2_LOG_INFO(fmt("Issue backup connection command CUID#%" PRId64
                       ", addr=%s", command->getCuid(), (*i).c_str()));
       getDownloadEngine()->addCommand(command);
       return info;
@@ -165,7 +165,7 @@ void InitiateConnectionCommand::setupBackupConnection
 (const std::string& hostname, const std::string& addr, uint16_t port,
  ConnectCommand* c)
 {
-  SharedHandle<BackupConnectInfo> backupConnectInfo
+  std::shared_ptr<BackupConnectInfo> backupConnectInfo
     = createBackupIPv4ConnectCommand(hostname, addr, port, c);
   if(backupConnectInfo) {
     c->setBackupConnectInfo(backupConnectInfo);
diff --git a/src/InitiateConnectionCommand.h b/src/InitiateConnectionCommand.h
index def24b0a..c5e476a3 100644
--- a/src/InitiateConnectionCommand.h
+++ b/src/InitiateConnectionCommand.h
@@ -61,14 +61,14 @@ protected:
   virtual Command* createNextCommand
   (const std::string& hostname, const std::string& addr, uint16_t port,
    const std::vector<std::string>& resolvedAddresses,
-   const SharedHandle<Request>& proxyRequest) = 0;
+   const std::shared_ptr<Request>& proxyRequest) = 0;
 
   void setConnectedAddrInfo
-  (const SharedHandle<Request>& req,
+  (const std::shared_ptr<Request>& req,
    const std::string& hostname,
-   const SharedHandle<SocketCore>& socket);
+   const std::shared_ptr<SocketCore>& socket);
 
-  SharedHandle<BackupConnectInfo> createBackupIPv4ConnectCommand
+  std::shared_ptr<BackupConnectInfo> createBackupIPv4ConnectCommand
   (const std::string& hostname, const std::string& ipaddr, uint16_t port,
    Command* mainCommand);
 
@@ -76,8 +76,8 @@ protected:
   (const std::string& hostname, const std::string& addr, uint16_t port,
    ConnectCommand* c);
 public:
-  InitiateConnectionCommand(cuid_t cuid, const SharedHandle<Request>& req,
-                            const SharedHandle<FileEntry>& fileEntry,
+  InitiateConnectionCommand(cuid_t cuid, const std::shared_ptr<Request>& req,
+                            const std::shared_ptr<FileEntry>& fileEntry,
                             RequestGroup* requestGroup,
                             DownloadEngine* e);
 
diff --git a/src/InitiateConnectionCommandFactory.cc b/src/InitiateConnectionCommandFactory.cc
index 9b0b9096..2d4e6141 100644
--- a/src/InitiateConnectionCommandFactory.cc
+++ b/src/InitiateConnectionCommandFactory.cc
@@ -50,8 +50,8 @@ namespace aria2 {
 Command*
 InitiateConnectionCommandFactory::createInitiateConnectionCommand
 (cuid_t cuid,
- const SharedHandle<Request>& req,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<Request>& req,
+ const std::shared_ptr<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e)
 {
diff --git a/src/InitiateConnectionCommandFactory.h b/src/InitiateConnectionCommandFactory.h
index af4bb0ec..1cedf465 100644
--- a/src/InitiateConnectionCommandFactory.h
+++ b/src/InitiateConnectionCommandFactory.h
@@ -36,7 +36,9 @@
 #define D_INITIATE_CONNECTION_COMMAND_FACTORY_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "Command.h"
 
 namespace aria2 {
@@ -50,8 +52,8 @@ class InitiateConnectionCommandFactory {
 public:
   static Command*
   createInitiateConnectionCommand(cuid_t cuid,
-                                  const SharedHandle<Request>& req,
-                                  const SharedHandle<FileEntry>& fileEntry,
+                                  const std::shared_ptr<Request>& req,
+                                  const std::shared_ptr<FileEntry>& fileEntry,
                                   RequestGroup* requestGroup,
                                   DownloadEngine* e);
 };
diff --git a/src/InitiatorMSEHandshakeCommand.cc b/src/InitiatorMSEHandshakeCommand.cc
index 65b6c437..e5022921 100644
--- a/src/InitiatorMSEHandshakeCommand.cc
+++ b/src/InitiatorMSEHandshakeCommand.cc
@@ -62,10 +62,10 @@ namespace aria2 {
 InitiatorMSEHandshakeCommand::InitiatorMSEHandshakeCommand
 (cuid_t cuid,
  RequestGroup* requestGroup,
- const SharedHandle<Peer>& p,
+ const std::shared_ptr<Peer>& p,
  DownloadEngine* e,
- const SharedHandle<BtRuntime>& btRuntime,
- const SharedHandle<SocketCore>& s)
+ const std::shared_ptr<BtRuntime>& btRuntime,
+ const std::shared_ptr<SocketCore>& s)
   : PeerAbstractCommand(cuid, p, e, s),
     requestGroup_(requestGroup),
     btRuntime_(btRuntime),
@@ -149,7 +149,7 @@ bool InitiatorMSEHandshakeCommand::executeInternal() {
     }
     case INITIATOR_RECEIVE_PAD_D: {
       if(mseHandshake_->receivePad()) {
-        SharedHandle<PeerConnection> peerConnection
+        std::shared_ptr<PeerConnection> peerConnection
           (new PeerConnection(getCuid(), getPeer(), getSocket()));
         if(mseHandshake_->getNegotiatedCryptoType() ==
            MSEHandshake::CRYPTO_ARC4){
@@ -199,7 +199,7 @@ void InitiatorMSEHandshakeCommand::tryNewPeer()
 {
   if(peerStorage_->isPeerAvailable() && btRuntime_->lessThanEqMinPeers()) {
     cuid_t ncuid = getDownloadEngine()->newCUID();
-    SharedHandle<Peer> peer = peerStorage_->checkoutPeer(ncuid);
+    std::shared_ptr<Peer> peer = peerStorage_->checkoutPeer(ncuid);
     // sanity check
     if(peer) {
       PeerInitiateConnectionCommand* command;
@@ -254,18 +254,18 @@ bool InitiatorMSEHandshakeCommand::exitBeforeExecute()
 }
 
 void InitiatorMSEHandshakeCommand::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
 
 void InitiatorMSEHandshakeCommand::setPieceStorage
-(const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
 
-const SharedHandle<Option>& InitiatorMSEHandshakeCommand::getOption() const
+const std::shared_ptr<Option>& InitiatorMSEHandshakeCommand::getOption() const
 {
   return requestGroup_->getOption();
 }
diff --git a/src/InitiatorMSEHandshakeCommand.h b/src/InitiatorMSEHandshakeCommand.h
index 5b44abcb..5e80ca76 100644
--- a/src/InitiatorMSEHandshakeCommand.h
+++ b/src/InitiatorMSEHandshakeCommand.h
@@ -60,16 +60,16 @@ public:
 private:
   RequestGroup* requestGroup_;
 
-  SharedHandle<PeerStorage> peerStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
 
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
 
-  SharedHandle<BtRuntime> btRuntime_;
+  std::shared_ptr<BtRuntime> btRuntime_;
 
   Seq sequence_;
   MSEHandshake* mseHandshake_;
 
-  const SharedHandle<Option>& getOption() const;
+  const std::shared_ptr<Option>& getOption() const;
 
   void tryNewPeer();
 protected:
@@ -81,16 +81,16 @@ public:
   InitiatorMSEHandshakeCommand
   (cuid_t cuid,
    RequestGroup* requestGroup,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    DownloadEngine* e,
-   const SharedHandle<BtRuntime>& btRuntime,
-   const SharedHandle<SocketCore>& s);
+   const std::shared_ptr<BtRuntime>& btRuntime,
+   const std::shared_ptr<SocketCore>& s);
 
   virtual ~InitiatorMSEHandshakeCommand();
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 };
 
 } // namespace aria2
diff --git a/src/IteratableChecksumValidator.cc b/src/IteratableChecksumValidator.cc
index 405ba2bf..c07daafb 100644
--- a/src/IteratableChecksumValidator.cc
+++ b/src/IteratableChecksumValidator.cc
@@ -50,8 +50,8 @@
 namespace aria2 {
 
 IteratableChecksumValidator::IteratableChecksumValidator
-(const SharedHandle<DownloadContext>& dctx,
- const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<DownloadContext>& dctx,
+ const std::shared_ptr<PieceStorage>& pieceStorage)
   : dctx_(dctx),
     pieceStorage_(pieceStorage),
     currentOffset_(0)
diff --git a/src/IteratableChecksumValidator.h b/src/IteratableChecksumValidator.h
index 18d51efd..e747c57d 100644
--- a/src/IteratableChecksumValidator.h
+++ b/src/IteratableChecksumValidator.h
@@ -36,7 +36,8 @@
 #define D_ITERATABLE_CHECKSUM_VALIDATOR_H
 
 #include "IteratableValidator.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -47,16 +48,16 @@ class MessageDigest;
 class IteratableChecksumValidator:public IteratableValidator
 {
 private:
-  SharedHandle<DownloadContext> dctx_;
+  std::shared_ptr<DownloadContext> dctx_;
 
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
 
   int64_t currentOffset_;
 
-  SharedHandle<MessageDigest> ctx_;
+  std::shared_ptr<MessageDigest> ctx_;
 public:
-  IteratableChecksumValidator(const SharedHandle<DownloadContext>& dctx,
-                              const SharedHandle<PieceStorage>& pieceStorage);
+  IteratableChecksumValidator(const std::shared_ptr<DownloadContext>& dctx,
+                              const std::shared_ptr<PieceStorage>& pieceStorage);
 
   virtual ~IteratableChecksumValidator();
 
diff --git a/src/IteratableChunkChecksumValidator.cc b/src/IteratableChunkChecksumValidator.cc
index 17c2558c..a2fbce41 100644
--- a/src/IteratableChunkChecksumValidator.cc
+++ b/src/IteratableChunkChecksumValidator.cc
@@ -54,8 +54,8 @@
 namespace aria2 {
 
 IteratableChunkChecksumValidator::IteratableChunkChecksumValidator
-(const SharedHandle<DownloadContext>& dctx,
- const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<DownloadContext>& dctx,
+ const std::shared_ptr<PieceStorage>& pieceStorage)
   : dctx_(dctx),
     pieceStorage_(pieceStorage),
     bitfield_(new BitfieldMan(dctx_->getPieceLength(),
diff --git a/src/IteratableChunkChecksumValidator.h b/src/IteratableChunkChecksumValidator.h
index ed72ebb4..ef42d9e9 100644
--- a/src/IteratableChunkChecksumValidator.h
+++ b/src/IteratableChunkChecksumValidator.h
@@ -38,8 +38,7 @@
 #include "IteratableValidator.h"
 
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -51,19 +50,19 @@ class MessageDigest;
 class IteratableChunkChecksumValidator:public IteratableValidator
 {
 private:
-  SharedHandle<DownloadContext> dctx_;
-  SharedHandle<PieceStorage> pieceStorage_;
-  SharedHandle<BitfieldMan> bitfield_;
+  std::shared_ptr<DownloadContext> dctx_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
+  std::shared_ptr<BitfieldMan> bitfield_;
   size_t currentIndex_;
-  SharedHandle<MessageDigest> ctx_;
+  std::shared_ptr<MessageDigest> ctx_;
 
   std::string calculateActualChecksum();
 
   std::string digest(int64_t offset, size_t length);
 
 public:
-  IteratableChunkChecksumValidator(const SharedHandle<DownloadContext>& dctx,
-                                   const SharedHandle<PieceStorage>& pieceStorage);
+  IteratableChunkChecksumValidator(const std::shared_ptr<DownloadContext>& dctx,
+                                   const std::shared_ptr<PieceStorage>& pieceStorage);
 
   virtual ~IteratableChunkChecksumValidator();
 
diff --git a/src/JsonParser.cc b/src/JsonParser.cc
index bae75286..d5501f18 100644
--- a/src/JsonParser.cc
+++ b/src/JsonParser.cc
@@ -33,8 +33,10 @@
  */
 /* copyright --> */
 #include "JsonParser.h"
-#include "StructParserStateMachine.h"
 
+#include <cassert>
+
+#include "StructParserStateMachine.h"
 #include "util.h"
 
 namespace aria2 {
diff --git a/src/KqueueEventPoll.cc b/src/KqueueEventPoll.cc
index 6cf6c66d..d1610318 100644
--- a/src/KqueueEventPoll.cc
+++ b/src/KqueueEventPoll.cc
@@ -170,7 +170,7 @@ int translateEvents(EventPoll::EventType events)
 bool KqueueEventPoll::addEvents
 (sock_t socket, const KqueueEventPoll::KEvent& event)
 {
-  SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
+  std::shared_ptr<KSocketEntry> socketEntry(new KSocketEntry(socket));
   KSocketEntrySet::iterator i = socketEntries_.lower_bound(socketEntry);
   int r = 0;
   struct timespec zeroTimeout = { 0, 0 };
@@ -210,7 +210,7 @@ bool KqueueEventPoll::addEvents(sock_t socket, Command* command,
 
 #ifdef ENABLE_ASYNC_DNS
 bool KqueueEventPoll::addEvents(sock_t socket, Command* command, int events,
-                                const SharedHandle<AsyncNameResolver>& rs)
+                                const std::shared_ptr<AsyncNameResolver>& rs)
 {
   return addEvents(socket, KADNSEvent(rs, command, socket, events));
 }
@@ -219,7 +219,7 @@ bool KqueueEventPoll::addEvents(sock_t socket, Command* command, int events,
 bool KqueueEventPoll::deleteEvents(sock_t socket,
                                   const KqueueEventPoll::KEvent& event)
 {
-  SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
+  std::shared_ptr<KSocketEntry> socketEntry(new KSocketEntry(socket));
   KSocketEntrySet::iterator i = socketEntries_.find(socketEntry);
   if(i == socketEntries_.end()) {
     A2_LOG_DEBUG(fmt("Socket %d is not found in SocketEntries.", socket));
@@ -247,7 +247,7 @@ bool KqueueEventPoll::deleteEvents(sock_t socket,
 
 #ifdef ENABLE_ASYNC_DNS
 bool KqueueEventPoll::deleteEvents(sock_t socket, Command* command,
-                                  const SharedHandle<AsyncNameResolver>& rs)
+                                  const std::shared_ptr<AsyncNameResolver>& rs)
 {
   return deleteEvents(socket, KADNSEvent(rs, command, socket, 0));
 }
@@ -262,9 +262,9 @@ bool KqueueEventPoll::deleteEvents(sock_t socket, Command* command,
 
 #ifdef ENABLE_ASYNC_DNS
 bool KqueueEventPoll::addNameResolver
-(const SharedHandle<AsyncNameResolver>& resolver, Command* command)
+(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
-  SharedHandle<KAsyncNameResolverEntry> entry
+  std::shared_ptr<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   KAsyncNameResolverEntrySet::iterator itr = nameResolverEntries_.find(entry);
   if(itr == nameResolverEntries_.end()) {
@@ -277,9 +277,9 @@ bool KqueueEventPoll::addNameResolver
 }
 
 bool KqueueEventPoll::deleteNameResolver
-(const SharedHandle<AsyncNameResolver>& resolver, Command* command)
+(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
-  SharedHandle<KAsyncNameResolverEntry> entry
+  std::shared_ptr<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   KAsyncNameResolverEntrySet::iterator itr = nameResolverEntries_.find(entry);
   if(itr == nameResolverEntries_.end()) {
diff --git a/src/KqueueEventPoll.h b/src/KqueueEventPoll.h
index 2ab6aff7..c84d2078 100644
--- a/src/KqueueEventPoll.h
+++ b/src/KqueueEventPoll.h
@@ -75,12 +75,12 @@ private:
   friend int accumulateEvent(int events, const KEvent& event);
 
 private:
-  typedef std::set<SharedHandle<KSocketEntry>,
-                   DerefLess<SharedHandle<KSocketEntry> > > KSocketEntrySet;
+  typedef std::set<std::shared_ptr<KSocketEntry>,
+                   DerefLess<std::shared_ptr<KSocketEntry> > > KSocketEntrySet;
   KSocketEntrySet socketEntries_;
 #ifdef ENABLE_ASYNC_DNS
-  typedef std::set<SharedHandle<KAsyncNameResolverEntry>,
-                   DerefLess<SharedHandle<KAsyncNameResolverEntry> > >
+  typedef std::set<std::shared_ptr<KAsyncNameResolverEntry>,
+                   DerefLess<std::shared_ptr<KAsyncNameResolverEntry> > >
   KAsyncNameResolverEntrySet;
   KAsyncNameResolverEntrySet nameResolverEntries_;
 #endif // ENABLE_ASYNC_DNS
@@ -98,10 +98,10 @@ private:
   bool deleteEvents(sock_t socket, const KEvent& event);
 
   bool addEvents(sock_t socket, Command* command, int events,
-                 const SharedHandle<AsyncNameResolver>& rs);
+                 const std::shared_ptr<AsyncNameResolver>& rs);
 
   bool deleteEvents(sock_t socket, Command* command,
-                    const SharedHandle<AsyncNameResolver>& rs);
+                    const std::shared_ptr<AsyncNameResolver>& rs);
 
 public:
   KqueueEventPoll();
@@ -119,10 +119,10 @@ public:
                             Command* command, EventPoll::EventType events);
 #ifdef ENABLE_ASYNC_DNS
 
-  virtual bool addNameResolver(const SharedHandle<AsyncNameResolver>& resolver,
+  virtual bool addNameResolver(const std::shared_ptr<AsyncNameResolver>& resolver,
                                Command* command);
   virtual bool deleteNameResolver
-  (const SharedHandle<AsyncNameResolver>& resolver, Command* command);
+  (const std::shared_ptr<AsyncNameResolver>& resolver, Command* command);
 #endif // ENABLE_ASYNC_DNS
 
   static const int IEV_READ = POLLIN;
diff --git a/src/LibgcryptMessageDigestImpl.cc b/src/LibgcryptMessageDigestImpl.cc
index 84c3f8bc..23ae1389 100644
--- a/src/LibgcryptMessageDigestImpl.cc
+++ b/src/LibgcryptMessageDigestImpl.cc
@@ -51,9 +51,9 @@ MessageDigestImpl::~MessageDigestImpl()
   gcry_md_close(ctx_);
 }
 
-SharedHandle<MessageDigestImpl> MessageDigestImpl::sha1()
+std::shared_ptr<MessageDigestImpl> MessageDigestImpl::sha1()
 {
-  return SharedHandle<MessageDigestImpl>(new MessageDigestImpl(GCRY_MD_SHA1));
+  return std::shared_ptr<MessageDigestImpl>(new MessageDigestImpl(GCRY_MD_SHA1));
 }
 
 typedef HashFuncEntry<int> CHashFuncEntry;
@@ -70,11 +70,11 @@ CHashFuncEntry hashFuncs[] = {
 };
 } // namespace
 
-SharedHandle<MessageDigestImpl> MessageDigestImpl::create
+std::shared_ptr<MessageDigestImpl> MessageDigestImpl::create
 (const std::string& hashType)
 {
   int hashFunc = getHashFunc(vbegin(hashFuncs), vend(hashFuncs), hashType);
-  return SharedHandle<MessageDigestImpl>(new MessageDigestImpl(hashFunc));
+  return std::shared_ptr<MessageDigestImpl>(new MessageDigestImpl(hashFunc));
 }
 
 bool MessageDigestImpl::supports(const std::string& hashType)
diff --git a/src/LibgcryptMessageDigestImpl.h b/src/LibgcryptMessageDigestImpl.h
index 1bec9154..212e09a7 100644
--- a/src/LibgcryptMessageDigestImpl.h
+++ b/src/LibgcryptMessageDigestImpl.h
@@ -38,11 +38,10 @@
 #include "common.h"
 
 #include <string>
+#include <memory>
 
 #include <gcrypt.h>
 
-#include "SharedHandle.h"
-
 namespace aria2 {
 
 class MessageDigestImpl {
@@ -58,8 +57,8 @@ private:
 public:
   ~MessageDigestImpl();
 
-  static SharedHandle<MessageDigestImpl> sha1();
-  static SharedHandle<MessageDigestImpl> create(const std::string& hashType);
+  static std::shared_ptr<MessageDigestImpl> sha1();
+  static std::shared_ptr<MessageDigestImpl> create(const std::string& hashType);
 
   static bool supports(const std::string& hashType);
   static size_t getDigestLength(const std::string& hashType);
diff --git a/src/LibnettleMessageDigestImpl.cc b/src/LibnettleMessageDigestImpl.cc
index d8eac9b7..5f49648d 100644
--- a/src/LibnettleMessageDigestImpl.cc
+++ b/src/LibnettleMessageDigestImpl.cc
@@ -53,9 +53,9 @@ MessageDigestImpl::~MessageDigestImpl()
   delete [] ctx_;
 }
 
-SharedHandle<MessageDigestImpl> MessageDigestImpl::sha1()
+std::shared_ptr<MessageDigestImpl> MessageDigestImpl::sha1()
 {
-  return SharedHandle<MessageDigestImpl>(new MessageDigestImpl(&nettle_sha1));
+  return std::shared_ptr<MessageDigestImpl>(new MessageDigestImpl(&nettle_sha1));
 }
 
 typedef HashFuncEntry<const nettle_hash*> CHashFuncEntry;
@@ -72,12 +72,12 @@ CHashFuncEntry hashFuncs[] = {
 };
 } // namespace
 
-SharedHandle<MessageDigestImpl> MessageDigestImpl::create
+std::shared_ptr<MessageDigestImpl> MessageDigestImpl::create
 (const std::string& hashType)
 {
   const nettle_hash* hashInfo =
     getHashFunc(vbegin(hashFuncs), vend(hashFuncs), hashType);
-  return SharedHandle<MessageDigestImpl>(new MessageDigestImpl(hashInfo));
+  return std::shared_ptr<MessageDigestImpl>(new MessageDigestImpl(hashInfo));
 }
 
 bool MessageDigestImpl::supports(const std::string& hashType)
diff --git a/src/LibnettleMessageDigestImpl.h b/src/LibnettleMessageDigestImpl.h
index 3c6a86d6..2028885f 100644
--- a/src/LibnettleMessageDigestImpl.h
+++ b/src/LibnettleMessageDigestImpl.h
@@ -38,11 +38,10 @@
 #include "common.h"
 
 #include <string>
+#include <memory>
 
 #include <nettle/nettle-meta.h>
 
-#include "SharedHandle.h"
-
 namespace aria2 {
 
 class MessageDigestImpl {
@@ -58,8 +57,8 @@ private:
 public:
   ~MessageDigestImpl();
 
-  static SharedHandle<MessageDigestImpl> sha1();
-  static SharedHandle<MessageDigestImpl> create(const std::string& hashType);
+  static std::shared_ptr<MessageDigestImpl> sha1();
+  static std::shared_ptr<MessageDigestImpl> create(const std::string& hashType);
 
   static bool supports(const std::string& hashType);
   static size_t getDigestLength(const std::string& hashType);
diff --git a/src/LibsslMessageDigestImpl.cc b/src/LibsslMessageDigestImpl.cc
index 2ef9bfb7..8a024041 100644
--- a/src/LibsslMessageDigestImpl.cc
+++ b/src/LibsslMessageDigestImpl.cc
@@ -52,9 +52,9 @@ MessageDigestImpl::~MessageDigestImpl()
   EVP_MD_CTX_cleanup(&ctx_);
 }
 
-SharedHandle<MessageDigestImpl> MessageDigestImpl::sha1()
+std::shared_ptr<MessageDigestImpl> MessageDigestImpl::sha1()
 {
-  return SharedHandle<MessageDigestImpl>(new MessageDigestImpl(EVP_sha1()));
+  return std::shared_ptr<MessageDigestImpl>(new MessageDigestImpl(EVP_sha1()));
 }
 
 typedef HashFuncEntry<const EVP_MD*> CHashFuncEntry;
@@ -79,12 +79,12 @@ CHashFuncEntry hashFuncs[] = {
 };
 } // namespace
 
-SharedHandle<MessageDigestImpl> MessageDigestImpl::create
+std::shared_ptr<MessageDigestImpl> MessageDigestImpl::create
 (const std::string& hashType)
 {
   const EVP_MD* hashFunc = getHashFunc(vbegin(hashFuncs), vend(hashFuncs),
                                        hashType);
-  return SharedHandle<MessageDigestImpl>(new MessageDigestImpl(hashFunc));
+  return std::shared_ptr<MessageDigestImpl>(new MessageDigestImpl(hashFunc));
 }
 
 bool MessageDigestImpl::supports(const std::string& hashType)
diff --git a/src/LibsslMessageDigestImpl.h b/src/LibsslMessageDigestImpl.h
index 1557c4c2..6d3a89f8 100644
--- a/src/LibsslMessageDigestImpl.h
+++ b/src/LibsslMessageDigestImpl.h
@@ -38,11 +38,10 @@
 #include "common.h"
 
 #include <string>
+#include <memory>
 
 #include <openssl/evp.h>
 
-#include "SharedHandle.h"
-
 namespace aria2 {
 
 class MessageDigestImpl {
@@ -58,8 +57,8 @@ private:
 public:
   ~MessageDigestImpl();
 
-  static SharedHandle<MessageDigestImpl> sha1();
-  static SharedHandle<MessageDigestImpl> create(const std::string& hashType);
+  static std::shared_ptr<MessageDigestImpl> sha1();
+  static std::shared_ptr<MessageDigestImpl> create(const std::string& hashType);
 
   static bool supports(const std::string& hashType);
   static size_t getDigestLength(const std::string& hashType);
diff --git a/src/LibuvEventPoll.cc b/src/LibuvEventPoll.cc
index 2509357f..1c415d2d 100644
--- a/src/LibuvEventPoll.cc
+++ b/src/LibuvEventPoll.cc
@@ -214,7 +214,7 @@ void LibuvEventPoll::pollCallback(KPoll* poll, int status, int events)
 bool LibuvEventPoll::addEvents(sock_t socket,
                                const LibuvEventPoll::KEvent& event)
 {
-  SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
+  std::shared_ptr<KSocketEntry> socketEntry(new KSocketEntry(socket));
   KSocketEntrySet::iterator i = socketEntries_.lower_bound(socketEntry);
 
   if (i != socketEntries_.end() && **i == *socketEntry) {
@@ -243,7 +243,7 @@ bool LibuvEventPoll::addEvents(sock_t socket, Command* command, EventPoll::Event
 
 #ifdef ENABLE_ASYNC_DNS
 bool LibuvEventPoll::addEvents(sock_t socket, Command* command, int events,
-                               const SharedHandle<AsyncNameResolver>& rs)
+                               const std::shared_ptr<AsyncNameResolver>& rs)
 {
   return addEvents(socket, KADNSEvent(rs, command, socket, events));
 }
@@ -252,7 +252,7 @@ bool LibuvEventPoll::addEvents(sock_t socket, Command* command, int events,
 bool LibuvEventPoll::deleteEvents(sock_t socket,
                                   const LibuvEventPoll::KEvent& event)
 {
-  SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
+  std::shared_ptr<KSocketEntry> socketEntry(new KSocketEntry(socket));
   KSocketEntrySet::iterator i = socketEntries_.find(socketEntry);
 
   if (i == socketEntries_.end()) {
@@ -280,7 +280,7 @@ bool LibuvEventPoll::deleteEvents(sock_t socket,
 
 #ifdef ENABLE_ASYNC_DNS
 bool LibuvEventPoll::deleteEvents(sock_t socket, Command* command,
-                                  const SharedHandle<AsyncNameResolver>& rs)
+                                  const std::shared_ptr<AsyncNameResolver>& rs)
 {
   return deleteEvents(socket, KADNSEvent(rs, command, socket, 0));
 }
@@ -294,10 +294,10 @@ bool LibuvEventPoll::deleteEvents(sock_t socket, Command* command,
 }
 
 #ifdef ENABLE_ASYNC_DNS
-bool LibuvEventPoll::addNameResolver(const SharedHandle<AsyncNameResolver>& resolver,
+bool LibuvEventPoll::addNameResolver(const std::shared_ptr<AsyncNameResolver>& resolver,
                                      Command* command)
 {
-  SharedHandle<KAsyncNameResolverEntry> entry(
+  std::shared_ptr<KAsyncNameResolverEntry> entry(
       new KAsyncNameResolverEntry(resolver, command));
   KAsyncNameResolverEntrySet::iterator itr =
     nameResolverEntries_.lower_bound(entry);
@@ -309,10 +309,10 @@ bool LibuvEventPoll::addNameResolver(const SharedHandle<AsyncNameResolver>& reso
   return true;
 }
 
-bool LibuvEventPoll::deleteNameResolver(const SharedHandle<AsyncNameResolver>& resolver,
+bool LibuvEventPoll::deleteNameResolver(const std::shared_ptr<AsyncNameResolver>& resolver,
                                         Command* command)
 {
-  SharedHandle<KAsyncNameResolverEntry> entry(
+  std::shared_ptr<KAsyncNameResolverEntry> entry(
       new KAsyncNameResolverEntry(resolver, command));
   KAsyncNameResolverEntrySet::iterator itr = nameResolverEntries_.find(entry);
   if (itr == nameResolverEntries_.end()) {
diff --git a/src/LibuvEventPoll.h b/src/LibuvEventPoll.h
index 5c058737..b7069176 100644
--- a/src/LibuvEventPoll.h
+++ b/src/LibuvEventPoll.h
@@ -105,14 +105,14 @@ private:
     }
   };
 
-  typedef std::set<SharedHandle<KSocketEntry>,
-                   DerefLess<SharedHandle<KSocketEntry> > > KSocketEntrySet;
+  typedef std::set<std::shared_ptr<KSocketEntry>,
+                   DerefLess<std::shared_ptr<KSocketEntry> > > KSocketEntrySet;
 
   typedef std::map<sock_t, KPoll*> KPolls;
 
 #ifdef ENABLE_ASYNC_DNS
-  typedef std::set<SharedHandle<KAsyncNameResolverEntry>,
-                   DerefLess<SharedHandle<KAsyncNameResolverEntry> > >
+  typedef std::set<std::shared_ptr<KAsyncNameResolverEntry>,
+                   DerefLess<std::shared_ptr<KAsyncNameResolverEntry> > >
   KAsyncNameResolverEntrySet;
 #endif // ENABLE_ASYNC_DNS
 
@@ -130,9 +130,9 @@ private:
 
 #ifdef ENABLE_ASYNC_DNS
   bool addEvents(sock_t socket, Command* command, int events,
-                 const SharedHandle<AsyncNameResolver>& rs);
+                 const std::shared_ptr<AsyncNameResolver>& rs);
   bool deleteEvents(sock_t socket, Command* command,
-                    const SharedHandle<AsyncNameResolver>& rs);
+                    const std::shared_ptr<AsyncNameResolver>& rs);
 #endif
 
   static int translateEvents(EventPoll::EventType events);
@@ -151,10 +151,10 @@ public:
                             Command* command, EventPoll::EventType events);
 
 #ifdef ENABLE_ASYNC_DNS
-  virtual bool addNameResolver(const SharedHandle<AsyncNameResolver>& resolver,
+  virtual bool addNameResolver(const std::shared_ptr<AsyncNameResolver>& resolver,
                                Command* command);
   virtual bool deleteNameResolver(
-      const SharedHandle<AsyncNameResolver>& resolver, Command* command);
+      const std::shared_ptr<AsyncNameResolver>& resolver, Command* command);
 #endif // ENABLE_ASYNC_DNS
 
   static const int IEV_READ = UV_READABLE;
diff --git a/src/LogFactory.cc b/src/LogFactory.cc
index 126397ae..66b0fa77 100644
--- a/src/LogFactory.cc
+++ b/src/LogFactory.cc
@@ -40,12 +40,12 @@
 namespace aria2 {
 
 std::string LogFactory::filename_ = DEV_NULL;
-SharedHandle<Logger> LogFactory::logger_;
+std::shared_ptr<Logger> LogFactory::logger_;
 bool LogFactory::consoleOutput_ = true;
 Logger::LEVEL LogFactory::logLevel_ = Logger::A2_DEBUG;
 Logger::LEVEL LogFactory::consoleLogLevel_ = Logger::A2_NOTICE;
 
-void LogFactory::openLogger(const SharedHandle<Logger>& logger)
+void LogFactory::openLogger(const std::shared_ptr<Logger>& logger)
 {
   if(filename_ != DEV_NULL) {
     // don't open file DEV_NULL for performance sake.
@@ -70,10 +70,10 @@ void LogFactory::reconfigure()
   }
 }
 
-const SharedHandle<Logger>& LogFactory::getInstance()
+const std::shared_ptr<Logger>& LogFactory::getInstance()
 {
   if(!logger_) {
-    SharedHandle<Logger> slogger(new Logger());
+    std::shared_ptr<Logger> slogger(new Logger());
     openLogger(slogger);
     logger_.swap(slogger);
   }
diff --git a/src/LogFactory.h b/src/LogFactory.h
index b80aadd8..d28b115f 100644
--- a/src/LogFactory.h
+++ b/src/LogFactory.h
@@ -38,21 +38,21 @@
 #include "common.h"
 
 #include <string>
+#include <memory>
 
 #include "Logger.h"
-#include "SharedHandle.h"
 
 namespace aria2 {
 
 class LogFactory {
 private:
   static std::string filename_;
-  static SharedHandle<Logger> logger_;
+  static std::shared_ptr<Logger> logger_;
   static bool consoleOutput_;
   static Logger::LEVEL logLevel_;
   static Logger::LEVEL consoleLogLevel_;
 
-  static void openLogger(const SharedHandle<Logger>& logger);
+  static void openLogger(const std::shared_ptr<Logger>& logger);
 
   LogFactory();
 public:
@@ -60,7 +60,7 @@ public:
    * Get logger instance. Returned logger is singleton.
    * This function is not thread-safe.
    */
-  static const SharedHandle<Logger>& getInstance();
+  static const std::shared_ptr<Logger>& getInstance();
 
   /**
    * Set a filename to write log. If name is "-", log is written to
@@ -112,14 +112,14 @@ public:
 
 #define A2_LOG(level, msg)                                              \
   {                                                                     \
-    const aria2::SharedHandle<aria2::Logger>& logger =                  \
+    const std::shared_ptr<aria2::Logger>& logger =                  \
       aria2::LogFactory::getInstance();                                 \
     if(logger->levelEnabled(level))                                     \
       logger->log(level, __FILE__, __LINE__, msg);                      \
   }
 #define A2_LOG_EX(level, msg, ex)                                       \
   {                                                                     \
-    const aria2::SharedHandle<aria2::Logger>& logger =                  \
+    const std::shared_ptr<aria2::Logger>& logger =                  \
       aria2::LogFactory::getInstance();                                 \
     if(logger->levelEnabled(level))                                     \
       logger->log(level, __FILE__, __LINE__, msg, ex);                  \
diff --git a/src/Logger.cc b/src/Logger.cc
index 0df67660..6115db4e 100644
--- a/src/Logger.cc
+++ b/src/Logger.cc
@@ -37,6 +37,7 @@
 #include <unistd.h>
 #include <cstring>
 #include <cstdio>
+#include <cassert>
 
 #include "DlAbortEx.h"
 #include "fmt.h"
diff --git a/src/Logger.h b/src/Logger.h
index c3a91e1a..a68ab72f 100644
--- a/src/Logger.h
+++ b/src/Logger.h
@@ -38,8 +38,7 @@
 #include "common.h"
 
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -58,7 +57,7 @@ public:
 private:
   // Minimum log level for file log output.
   LEVEL logLevel_;
-  SharedHandle<OutputFile> fpp_;
+  std::shared_ptr<OutputFile> fpp_;
   // Minimum log level for console log output.
   LEVEL consoleLogLevel_;
   // true if console log output is enabled.
diff --git a/src/LpdDispatchMessageCommand.cc b/src/LpdDispatchMessageCommand.cc
index 00c74808..d2a54fbf 100644
--- a/src/LpdDispatchMessageCommand.cc
+++ b/src/LpdDispatchMessageCommand.cc
@@ -47,7 +47,7 @@ namespace aria2 {
 
 LpdDispatchMessageCommand::LpdDispatchMessageCommand
 (cuid_t cuid,
- const SharedHandle<LpdMessageDispatcher>& dispatcher,
+ const std::shared_ptr<LpdMessageDispatcher>& dispatcher,
  DownloadEngine* e)
   : Command(cuid),
     dispatcher_(dispatcher),
diff --git a/src/LpdDispatchMessageCommand.h b/src/LpdDispatchMessageCommand.h
index cd53cfa0..1fa8b018 100644
--- a/src/LpdDispatchMessageCommand.h
+++ b/src/LpdDispatchMessageCommand.h
@@ -36,7 +36,8 @@
 #define D_LPD_DISPATCH_MESSAGE_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -46,21 +47,21 @@ class BtRuntime;
 
 class LpdDispatchMessageCommand:public Command {
 private:
-  SharedHandle<LpdMessageDispatcher> dispatcher_;
+  std::shared_ptr<LpdMessageDispatcher> dispatcher_;
   DownloadEngine* e_;
   int tryCount_;
-  SharedHandle<BtRuntime> btRuntime_;
+  std::shared_ptr<BtRuntime> btRuntime_;
 public:
   LpdDispatchMessageCommand
   (cuid_t cuid,
-   const SharedHandle<LpdMessageDispatcher>& dispatcher,
+   const std::shared_ptr<LpdMessageDispatcher>& dispatcher,
    DownloadEngine* e);
 
   ~LpdDispatchMessageCommand();
 
   virtual bool execute();
 
-  void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime)
+  void setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime)
   {
     btRuntime_ = btRuntime;
   }
diff --git a/src/LpdMessage.cc b/src/LpdMessage.cc
index adc14cc0..f7a4311c 100644
--- a/src/LpdMessage.cc
+++ b/src/LpdMessage.cc
@@ -38,7 +38,7 @@ namespace aria2 {
 LpdMessage::LpdMessage() {}
 
 LpdMessage::LpdMessage
-(const SharedHandle<Peer>& peer, const std::string& infoHash)
+(const std::shared_ptr<Peer>& peer, const std::string& infoHash)
   : peer(peer), infoHash(infoHash)
 {}
 
diff --git a/src/LpdMessage.h b/src/LpdMessage.h
index 42d55678..893d67b9 100644
--- a/src/LpdMessage.h
+++ b/src/LpdMessage.h
@@ -36,18 +36,17 @@
 #include "common.h"
 
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
 class Peer;
 
 struct LpdMessage {
-  SharedHandle<Peer> peer;
+  std::shared_ptr<Peer> peer;
   std::string infoHash;
   LpdMessage();
-  LpdMessage(const SharedHandle<Peer>& peer, const std::string& infoHash);
+  LpdMessage(const std::shared_ptr<Peer>& peer, const std::string& infoHash);
   ~LpdMessage();
 };
 
diff --git a/src/LpdMessageDispatcher.h b/src/LpdMessageDispatcher.h
index e4685416..6fa02549 100644
--- a/src/LpdMessageDispatcher.h
+++ b/src/LpdMessageDispatcher.h
@@ -36,8 +36,8 @@
 #include "common.h"
 
 #include <string>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimerA2.h"
 
 namespace aria2 {
@@ -46,7 +46,7 @@ class SocketCore;
 
 class LpdMessageDispatcher {
 private:
-  SharedHandle<SocketCore> socket_;
+  std::shared_ptr<SocketCore> socket_;
   std::string infoHash_;
   uint16_t port_;
   std::string multicastAddress_;
diff --git a/src/LpdMessageReceiver.cc b/src/LpdMessageReceiver.cc
index 49da2d64..20d9f02a 100644
--- a/src/LpdMessageReceiver.cc
+++ b/src/LpdMessageReceiver.cc
@@ -77,9 +77,9 @@ bool LpdMessageReceiver::init(const std::string& localAddr)
   return false;
 }
 
-SharedHandle<LpdMessage> LpdMessageReceiver::receiveMessage()
+std::shared_ptr<LpdMessage> LpdMessageReceiver::receiveMessage()
 {
-  SharedHandle<LpdMessage> msg;
+  std::shared_ptr<LpdMessage> msg;
   while(1) {
     unsigned char buf[200];
     std::pair<std::string, uint16_t> peerAddr;
@@ -103,7 +103,7 @@ SharedHandle<LpdMessage> LpdMessageReceiver::receiveMessage()
       A2_LOG_INFO_EX("Failed to parse LPD message.", e);
       continue;
     }
-    const SharedHandle<HttpHeader>& header = proc.getResult();
+    const std::shared_ptr<HttpHeader>& header = proc.getResult();
     const std::string& infoHashString = header->find(HttpHeader::INFOHASH);
     uint32_t port = 0;
     if(!util::parseUIntNoThrow(port, header->find(HttpHeader::PORT)) ||
@@ -123,7 +123,7 @@ SharedHandle<LpdMessage> LpdMessageReceiver::receiveMessage()
                       infoHashString.c_str()));
       continue;
     }
-    SharedHandle<Peer> peer(new Peer(peerAddr.first, port, false));
+    std::shared_ptr<Peer> peer(new Peer(peerAddr.first, port, false));
     if(util::inPrivateAddress(peerAddr.first)) {
       peer->setLocalPeer(true);
     }
diff --git a/src/LpdMessageReceiver.h b/src/LpdMessageReceiver.h
index c3061fd8..40369508 100644
--- a/src/LpdMessageReceiver.h
+++ b/src/LpdMessageReceiver.h
@@ -36,8 +36,7 @@
 #include "common.h"
 
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -46,7 +45,7 @@ struct LpdMessage;
 
 class LpdMessageReceiver {
 private:
-  SharedHandle<SocketCore> socket_;
+  std::shared_ptr<SocketCore> socket_;
   std::string multicastAddress_;
   uint16_t multicastPort_;
   std::string localAddress_;
@@ -62,11 +61,11 @@ public:
 
   // Receives LPD message and returns LpdMessage which contains
   // sender(peer) and infohash. If no data is available on socket,
-  // returns SharedHandle<LpdMessage>().  If received data is bad,
-  // then returns SharedHandle<LpdMessage>(new LpdMessage())
-  SharedHandle<LpdMessage> receiveMessage();
+  // returns std::shared_ptr<LpdMessage>().  If received data is bad,
+  // then returns std::shared_ptr<LpdMessage>(new LpdMessage())
+  std::shared_ptr<LpdMessage> receiveMessage();
 
-  const SharedHandle<SocketCore>& getSocket() const
+  const std::shared_ptr<SocketCore>& getSocket() const
   {
     return socket_;
   }
diff --git a/src/LpdReceiveMessageCommand.cc b/src/LpdReceiveMessageCommand.cc
index 81ad11cc..65641715 100644
--- a/src/LpdReceiveMessageCommand.cc
+++ b/src/LpdReceiveMessageCommand.cc
@@ -53,7 +53,7 @@ namespace aria2 {
 
 LpdReceiveMessageCommand::LpdReceiveMessageCommand
 (cuid_t cuid,
- const SharedHandle<LpdMessageReceiver>& receiver,
+ const std::shared_ptr<LpdMessageReceiver>& receiver,
  DownloadEngine* e)
   : Command(cuid),
     receiver_(receiver),
@@ -73,12 +73,12 @@ bool LpdReceiveMessageCommand::execute()
     return true;
   }
   for(size_t i = 0; i < 20; ++i) {
-    SharedHandle<LpdMessage> m = receiver_->receiveMessage();
+    std::shared_ptr<LpdMessage> m = receiver_->receiveMessage();
     if(!m) {
       break;
     }
-    SharedHandle<BtRegistry> reg = e_->getBtRegistry();
-    SharedHandle<DownloadContext> dctx = reg->getDownloadContext(m->infoHash);
+    std::shared_ptr<BtRegistry> reg = e_->getBtRegistry();
+    std::shared_ptr<DownloadContext> dctx = reg->getDownloadContext(m->infoHash);
     if(!dctx) {
       A2_LOG_DEBUG(fmt("Download Context is null for infohash=%s.",
                        util::toHex(m->infoHash).c_str()));
@@ -90,11 +90,11 @@ bool LpdReceiveMessageCommand::execute()
     }
     RequestGroup* group = dctx->getOwnerRequestGroup();
     assert(group);
-    const SharedHandle<BtObject>& btobj = reg->get(group->getGID());
+    const std::shared_ptr<BtObject>& btobj = reg->get(group->getGID());
     assert(btobj);
-    const SharedHandle<PeerStorage>& peerStorage = btobj->peerStorage;
+    const std::shared_ptr<PeerStorage>& peerStorage = btobj->peerStorage;
     assert(peerStorage);
-    SharedHandle<Peer> peer = m->peer;
+    std::shared_ptr<Peer> peer = m->peer;
     if(peerStorage->addPeer(peer)) {
       A2_LOG_DEBUG(fmt("LPD peer %s:%u local=%d added.",
                        peer->getIPAddress().c_str(), peer->getPort(),
diff --git a/src/LpdReceiveMessageCommand.h b/src/LpdReceiveMessageCommand.h
index dea604a2..09f3fe60 100644
--- a/src/LpdReceiveMessageCommand.h
+++ b/src/LpdReceiveMessageCommand.h
@@ -36,7 +36,8 @@
 #define D_LPD_RECEIVE_MESSAGE_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -46,17 +47,17 @@ class SocketCore;
 
 class LpdReceiveMessageCommand:public Command {
 private:
-  SharedHandle<LpdMessageReceiver> receiver_;
+  std::shared_ptr<LpdMessageReceiver> receiver_;
   DownloadEngine* e_;
 public:
   LpdReceiveMessageCommand
-  (cuid_t cuid, const SharedHandle<LpdMessageReceiver>& receiver,
+  (cuid_t cuid, const std::shared_ptr<LpdMessageReceiver>& receiver,
    DownloadEngine* e);
   virtual ~LpdReceiveMessageCommand();
 
   virtual bool execute();
 
-  const SharedHandle<LpdMessageReceiver>& getLpdMessageReceiver() const
+  const std::shared_ptr<LpdMessageReceiver>& getLpdMessageReceiver() const
   {
     return receiver_;
   }
diff --git a/src/MSEHandshake.cc b/src/MSEHandshake.cc
index 6e34ae30..b78a8b2e 100644
--- a/src/MSEHandshake.cc
+++ b/src/MSEHandshake.cc
@@ -72,7 +72,7 @@ const unsigned char* GENERATOR = reinterpret_cast<const unsigned char*>("2");
 
 MSEHandshake::MSEHandshake
 (cuid_t cuid,
- const SharedHandle<SocketCore>& socket,
+ const std::shared_ptr<SocketCore>& socket,
  const Option* op)
   : cuid_(cuid),
     socket_(socket),
@@ -422,7 +422,7 @@ bool MSEHandshake::findReceiverHashMarker()
 }
 
 bool MSEHandshake::receiveReceiverHashAndPadCLength
-(const std::vector<SharedHandle<DownloadContext> >& downloadContexts)
+(const std::vector<std::shared_ptr<DownloadContext> >& downloadContexts)
 {
   if(20+VC_LENGTH+CRYPTO_BITFIELD_LENGTH+2/*PadC length*/ > rbufLength_) {
     wantRead_ = true;
@@ -431,8 +431,8 @@ bool MSEHandshake::receiveReceiverHashAndPadCLength
   // resolve info hash
   // pointing to the position of HASH('req2', SKEY) xor HASH('req3', S)
   unsigned char* rbufptr = rbuf_;
-  SharedHandle<DownloadContext> downloadContext;
-  for(std::vector<SharedHandle<DownloadContext> >::const_iterator i =
+  std::shared_ptr<DownloadContext> downloadContext;
+  for(std::vector<std::shared_ptr<DownloadContext> >::const_iterator i =
         downloadContexts.begin(), eoi = downloadContexts.end();
       i != eoi; ++i) {
     unsigned char md[20];
diff --git a/src/MSEHandshake.h b/src/MSEHandshake.h
index be29e29f..68b00ef1 100644
--- a/src/MSEHandshake.h
+++ b/src/MSEHandshake.h
@@ -38,8 +38,8 @@
 #include "common.h"
 
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "BtConstants.h"
 #include "SocketBuffer.h"
 #include "Command.h"
@@ -77,7 +77,7 @@ private:
   static const size_t MAX_BUFFER_LENGTH = 636U;
 
   cuid_t cuid_;
-  SharedHandle<SocketCore> socket_;
+  std::shared_ptr<SocketCore> socket_;
   bool wantRead_;
   const Option* option_;
 
@@ -88,8 +88,8 @@ private:
 
   CRYPTO_TYPE negotiatedCryptoType_;
   DHKeyExchange* dh_;
-  SharedHandle<ARC4Encryptor> encryptor_;
-  SharedHandle<ARC4Encryptor> decryptor_;
+  std::shared_ptr<ARC4Encryptor> encryptor_;
+  std::shared_ptr<ARC4Encryptor> decryptor_;
   unsigned char infoHash_[INFO_HASH_LENGTH];
   unsigned char secret_[KEY_LENGTH];
   bool initiator_;
@@ -98,7 +98,7 @@ private:
   uint16_t padLength_;
   uint16_t iaLength_;
   unsigned char* ia_;
-  SharedHandle<MessageDigest> sha1_;
+  std::shared_ptr<MessageDigest> sha1_;
 
   void encryptAndSendData(unsigned char* data, size_t length);
 
@@ -122,7 +122,7 @@ private:
 
   void shiftBuffer(size_t offset);
 public:
-  MSEHandshake(cuid_t cuid, const SharedHandle<SocketCore>& socket,
+  MSEHandshake(cuid_t cuid, const std::shared_ptr<SocketCore>& socket,
                const Option* op);
 
   ~MSEHandshake();
@@ -168,7 +168,7 @@ public:
   bool findReceiverHashMarker();
 
   bool receiveReceiverHashAndPadCLength
-  (const std::vector<SharedHandle<DownloadContext> >& downloadContexts);
+  (const std::vector<std::shared_ptr<DownloadContext> >& downloadContexts);
 
   bool receiveReceiverIALength();
 
@@ -197,12 +197,12 @@ public:
     return negotiatedCryptoType_;
   }
 
-  const SharedHandle<ARC4Encryptor>& getEncryptor() const
+  const std::shared_ptr<ARC4Encryptor>& getEncryptor() const
   {
     return encryptor_;
   }
 
-  const SharedHandle<ARC4Encryptor>& getDecryptor() const
+  const std::shared_ptr<ARC4Encryptor>& getDecryptor() const
   {
     return decryptor_;
   }
diff --git a/src/Makefile.am b/src/Makefile.am
index c97b5b8e..c89aa097 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -54,7 +54,6 @@ SRCS =  option_processing.cc\
 	LogFactory.cc LogFactory.h\
 	TimerA2.cc TimerA2.h\
 	TimeA2.cc TimeA2.h\
-	SharedHandle.cc SharedHandle.h\
 	FeatureConfig.cc FeatureConfig.h\
 	DownloadEngineFactory.cc DownloadEngineFactory.h\
 	SpeedCalc.cc SpeedCalc.h\
diff --git a/src/MemoryPreDownloadHandler.h b/src/MemoryPreDownloadHandler.h
index c3fc8ca3..3c348982 100644
--- a/src/MemoryPreDownloadHandler.h
+++ b/src/MemoryPreDownloadHandler.h
@@ -50,7 +50,7 @@ public:
 
   virtual void execute(RequestGroup* requestGroup)
   {
-    SharedHandle<DiskWriterFactory> dwf(new DiskWriterFactoryType());
+    std::shared_ptr<DiskWriterFactory> dwf(new DiskWriterFactoryType());
     requestGroup->setDiskWriterFactory(dwf);
     requestGroup->setFileAllocationEnabled(false);
     requestGroup->setPreLocalFileCheckEnabled(false);
diff --git a/src/MessageDigest.cc b/src/MessageDigest.cc
index e0dc1644..1acb0b8b 100644
--- a/src/MessageDigest.cc
+++ b/src/MessageDigest.cc
@@ -69,16 +69,16 @@ MessageDigest::MessageDigest()
 MessageDigest::~MessageDigest()
 {}
 
-SharedHandle<MessageDigest> MessageDigest::sha1()
+std::shared_ptr<MessageDigest> MessageDigest::sha1()
 {
-  SharedHandle<MessageDigest> md(new MessageDigest());
+  std::shared_ptr<MessageDigest> md(new MessageDigest());
   md->pImpl_ = MessageDigestImpl::sha1();
   return md;
 }
 
-SharedHandle<MessageDigest> MessageDigest::create(const std::string& hashType)
+std::shared_ptr<MessageDigest> MessageDigest::create(const std::string& hashType)
 {
-  SharedHandle<MessageDigest> md(new MessageDigest());
+  std::shared_ptr<MessageDigest> md(new MessageDigest());
   md->pImpl_ = MessageDigestImpl::create(hashType);
   return md;
 }
diff --git a/src/MessageDigest.h b/src/MessageDigest.h
index f5e6ca55..d9c619b8 100644
--- a/src/MessageDigest.h
+++ b/src/MessageDigest.h
@@ -39,8 +39,7 @@
 
 #include <string>
 #include <vector>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -48,7 +47,7 @@ class MessageDigestImpl;
 
 class MessageDigest {
 private:
-  SharedHandle<MessageDigestImpl> pImpl_;
+  std::shared_ptr<MessageDigestImpl> pImpl_;
 
   MessageDigest();
 
@@ -60,11 +59,11 @@ public:
   ~MessageDigest();
 
   // Factory functions
-  static SharedHandle<MessageDigest> sha1();
+  static std::shared_ptr<MessageDigest> sha1();
 
   // Factory function which takes hashType as string.  Throws
   // exception if hashType is not supported.
-  static SharedHandle<MessageDigest> create(const std::string& hashType);
+  static std::shared_ptr<MessageDigest> create(const std::string& hashType);
 
   // Returns true if hashType is supported. Otherwise returns false.
   static bool supports(const std::string& hashType);
diff --git a/src/MetadataInfo.cc b/src/MetadataInfo.cc
index df3077a1..fd279961 100644
--- a/src/MetadataInfo.cc
+++ b/src/MetadataInfo.cc
@@ -34,9 +34,11 @@
 /* copyright --> */
 #include "MetadataInfo.h"
 
+#include <cassert>
+
 namespace aria2 {
 
-MetadataInfo::MetadataInfo(const SharedHandle<GroupId>& gid,
+MetadataInfo::MetadataInfo(const std::shared_ptr<GroupId>& gid,
                            const std::string& uri)
   : gid_(gid), uri_(uri)
 {}
@@ -45,4 +47,10 @@ MetadataInfo::MetadataInfo() {}
 
 MetadataInfo::~MetadataInfo() {}
 
+a2_gid_t MetadataInfo::getGID() const
+{
+  assert(gid_);
+  return gid_->getNumericId();
+}
+
 } // namespace aria2
diff --git a/src/MetadataInfo.h b/src/MetadataInfo.h
index 7a5ac7f9..7e9b1cd9 100644
--- a/src/MetadataInfo.h
+++ b/src/MetadataInfo.h
@@ -38,18 +38,18 @@
 #include "common.h"
 
 #include <string>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "GroupId.h"
 
 namespace aria2 {
 
 class MetadataInfo {
 private:
-  SharedHandle<GroupId> gid_;
+  std::shared_ptr<GroupId> gid_;
   std::string uri_;
 public:
-  MetadataInfo(const SharedHandle<GroupId>& gid, const std::string& uri);
+  MetadataInfo(const std::shared_ptr<GroupId>& gid, const std::string& uri);
 
   MetadataInfo();
 
@@ -65,11 +65,7 @@ public:
     return uri_;
   }
 
-  a2_gid_t getGID() const
-  {
-    assert(gid_);
-    return gid_->getNumericId();
-  }
+  a2_gid_t getGID() const;
 };
 
 } // namespace aria2
diff --git a/src/Metalink2RequestGroup.cc b/src/Metalink2RequestGroup.cc
index d849e52c..696f7c85 100644
--- a/src/Metalink2RequestGroup.cc
+++ b/src/Metalink2RequestGroup.cc
@@ -79,7 +79,7 @@ public:
   AccumulateNonP2PUri(std::vector<std::string>& urisPtr)
     :urisPtr(urisPtr) {}
 
-  void operator()(const SharedHandle<MetalinkResource>& resource) {
+  void operator()(const std::shared_ptr<MetalinkResource>& resource) {
     switch(resource->type) {
     case MetalinkResource::TYPE_HTTP:
     case MetalinkResource::TYPE_HTTPS:
@@ -98,7 +98,7 @@ class FindBitTorrentUri {
 public:
   FindBitTorrentUri() {}
 
-  bool operator()(const SharedHandle<MetalinkResource>& resource) {
+  bool operator()(const std::shared_ptr<MetalinkResource>& resource) {
     if(resource->type == MetalinkResource::TYPE_BITTORRENT) {
       return true;
     } else {
@@ -110,16 +110,16 @@ public:
 
 void
 Metalink2RequestGroup::generate
-(std::vector<SharedHandle<RequestGroup> >& groups,
+(std::vector<std::shared_ptr<RequestGroup> >& groups,
  const std::string& metalinkFile,
- const SharedHandle<Option>& option,
+ const std::shared_ptr<Option>& option,
  const std::string& baseUri)
 {
-  std::vector<SharedHandle<MetalinkEntry> > entries;
+  std::vector<std::shared_ptr<MetalinkEntry> > entries;
   metalink::parseAndQuery(entries, metalinkFile, option.get(), baseUri);
-  std::vector<SharedHandle<RequestGroup> > tempgroups;
+  std::vector<std::shared_ptr<RequestGroup> > tempgroups;
   createRequestGroup(tempgroups, entries, option);
-  SharedHandle<MetadataInfo> mi;
+  std::shared_ptr<MetadataInfo> mi;
   if(metalinkFile == DEV_STDIN) {
     mi.reset(new MetadataInfo());
   } else {
@@ -133,25 +133,25 @@ Metalink2RequestGroup::generate
 
 void
 Metalink2RequestGroup::generate
-(std::vector<SharedHandle<RequestGroup> >& groups,
- const SharedHandle<BinaryStream>& binaryStream,
- const SharedHandle<Option>& option,
+(std::vector<std::shared_ptr<RequestGroup> >& groups,
+ const std::shared_ptr<BinaryStream>& binaryStream,
+ const std::shared_ptr<Option>& option,
  const std::string& baseUri)
 {
-  std::vector<SharedHandle<MetalinkEntry> > entries;
+  std::vector<std::shared_ptr<MetalinkEntry> > entries;
   metalink::parseAndQuery(entries, binaryStream.get(), option.get(), baseUri);
-  std::vector<SharedHandle<RequestGroup> > tempgroups;
+  std::vector<std::shared_ptr<RequestGroup> > tempgroups;
   createRequestGroup(tempgroups, entries, option);
-  SharedHandle<MetadataInfo> mi(new MetadataInfo());
+  std::shared_ptr<MetadataInfo> mi(new MetadataInfo());
   setMetadataInfo(tempgroups.begin(), tempgroups.end(), mi);
   groups.insert(groups.end(), tempgroups.begin(), tempgroups.end());
 }
 
 void
 Metalink2RequestGroup::createRequestGroup
-(std::vector<SharedHandle<RequestGroup> >& groups,
- const std::vector<SharedHandle<MetalinkEntry> >& entries,
- const SharedHandle<Option>& optionTemplate)
+(std::vector<std::shared_ptr<RequestGroup> >& groups,
+ const std::vector<std::shared_ptr<MetalinkEntry> >& entries,
+ const std::shared_ptr<Option>& optionTemplate)
 {
   if(entries.empty()) {
     A2_LOG_NOTICE(EX_NO_RESULT_WITH_YOUR_PREFS);
@@ -171,7 +171,7 @@ Metalink2RequestGroup::createRequestGroup
   if(optionTemplate->get(PREF_METALINK_PREFERRED_PROTOCOL) != V_NONE) {
     preferredProtocol = optionTemplate->get(PREF_METALINK_PREFERRED_PROTOCOL);
   }
-  for(std::vector<SharedHandle<MetalinkEntry> >::const_iterator i =
+  for(std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator i =
         entries.begin(), eoi = entries.end(); i != eoi; ++i) {
     (*i)->dropUnsupportedResource();
     if((*i)->resources.empty() && (*i)->metaurls.empty()) {
@@ -184,7 +184,7 @@ Metalink2RequestGroup::createRequestGroup
         (preferredProtocol, -MetalinkResource::getLowestPriority());
     }
   }
-  std::vector<SharedHandle<MetalinkEntry> > selectedEntries;
+  std::vector<std::shared_ptr<MetalinkEntry> > selectedEntries;
   SegList<int> sgl;
   util::parseIntSegments(sgl, optionTemplate->get(PREF_SELECT_FILE));
   sgl.normalize();
@@ -203,21 +203,21 @@ Metalink2RequestGroup::createRequestGroup
   std::for_each(selectedEntries.begin(), selectedEntries.end(),
                 mem_fun_sh(&MetalinkEntry::reorderMetaurlsByPriority));
   std::vector<std::pair<std::string,
-    std::vector<SharedHandle<MetalinkEntry> > > > entryGroups;
+    std::vector<std::shared_ptr<MetalinkEntry> > > > entryGroups;
   metalink::groupEntryByMetaurlName(entryGroups, selectedEntries);
   for(std::vector<std::pair<std::string,
-        std::vector<SharedHandle<MetalinkEntry> > > >::const_iterator itr =
+        std::vector<std::shared_ptr<MetalinkEntry> > > >::const_iterator itr =
         entryGroups.begin(), eoi = entryGroups.end(); itr != eoi; ++itr) {
     const std::string& metaurl = (*itr).first;
-    const std::vector<SharedHandle<MetalinkEntry> >& mes = (*itr).second;
+    const std::vector<std::shared_ptr<MetalinkEntry> >& mes = (*itr).second;
     A2_LOG_INFO(fmt("Processing metaurl group metaurl=%s", metaurl.c_str()));
 #ifdef ENABLE_BITTORRENT
-    SharedHandle<RequestGroup> torrentRg;
+    std::shared_ptr<RequestGroup> torrentRg;
     if(!metaurl.empty()) {
       std::vector<std::string> uris;
       uris.push_back(metaurl);
       {
-        std::vector<SharedHandle<RequestGroup> > result;
+        std::vector<std::shared_ptr<RequestGroup> > result;
         createRequestGroupForUri(result, optionTemplate, uris,
                                  /* ignoreForceSequential = */true,
                                  /* ignoreLocalPath = */true);
@@ -233,22 +233,22 @@ Metalink2RequestGroup::createRequestGroup
         // tranparent metalink
         torrentRg->getDownloadContext()->setAcceptMetalink(false);
         // make it in-memory download
-        SharedHandle<PreDownloadHandler> preh
+        std::shared_ptr<PreDownloadHandler> preh
           (new MemoryBufferPreDownloadHandler());
-        SharedHandle<RequestGroupCriteria> cri(new TrueRequestGroupCriteria());
+        std::shared_ptr<RequestGroupCriteria> cri(new TrueRequestGroupCriteria());
         preh->setCriteria(cri);
         torrentRg->addPreDownloadHandler(preh);
         groups.push_back(torrentRg);
       }
     }
 #endif // ENABLE_BITTORRENT
-    SharedHandle<Option> option = util::copy(optionTemplate);
-    SharedHandle<RequestGroup> rg(new RequestGroup(GroupId::create(), option));
-    SharedHandle<DownloadContext> dctx;
+    std::shared_ptr<Option> option = util::copy(optionTemplate);
+    std::shared_ptr<RequestGroup> rg(new RequestGroup(GroupId::create(), option));
+    std::shared_ptr<DownloadContext> dctx;
     int numSplit = option->getAsInt(PREF_SPLIT);
     int maxConn = option->getAsInt(PREF_MAX_CONNECTION_PER_SERVER);
     if(mes.size() == 1) {
-      SharedHandle<MetalinkEntry> entry = mes[0];
+      std::shared_ptr<MetalinkEntry> entry = mes[0];
       A2_LOG_INFO(fmt(MSG_METALINK_QUEUEING, entry->getPath().c_str()));
       entry->reorderResourcesByPriority();
       std::vector<std::string> uris;
@@ -295,9 +295,9 @@ Metalink2RequestGroup::createRequestGroup
       dctx.reset(new DownloadContext());
       // piece length is overridden by the one in torrent file.
       dctx->setPieceLength(option->getAsInt(PREF_PIECE_LENGTH));
-      std::vector<SharedHandle<FileEntry> > fileEntries;
+      std::vector<std::shared_ptr<FileEntry> > fileEntries;
       int64_t offset = 0;
-      for(std::vector<SharedHandle<MetalinkEntry> >::const_iterator i =
+      for(std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator i =
             mes.begin(), eoi = mes.end(); i != eoi; ++i) {
         A2_LOG_INFO(fmt("Metalink: Queueing %s for download as a member.",
                         (*i)->getPath().c_str()));
@@ -306,7 +306,7 @@ Metalink2RequestGroup::createRequestGroup
         std::vector<std::string> uris;
         std::for_each((*i)->resources.begin(), (*i)->resources.end(),
                       AccumulateNonP2PUri(uris));
-        SharedHandle<FileEntry> fe
+        std::shared_ptr<FileEntry> fe
           (new FileEntry
            (util::applyDir(option->get(PREF_DIR), (*i)->file->getPath()),
             (*i)->file->getLength(), offset, uris));
@@ -335,7 +335,7 @@ Metalink2RequestGroup::createRequestGroup
     // Inject depenency between rg and torrentRg here if
     // torrentRg is true
     if(torrentRg) {
-      SharedHandle<Dependency> dep(new BtDependency(rg.get(), torrentRg));
+      std::shared_ptr<Dependency> dep(new BtDependency(rg.get(), torrentRg));
       rg->dependsOn(dep);
       torrentRg->belongsTo(rg->getGID());
       // metadata download may take very long time. If URIs are
@@ -344,8 +344,8 @@ Metalink2RequestGroup::createRequestGroup
       time_t currentBtStopTimeout =
         torrentRg->getOption()->getAsInt(PREF_BT_STOP_TIMEOUT);
       if(currentBtStopTimeout == 0 || currentBtStopTimeout > btStopTimeout) {
-        std::vector<SharedHandle<FileEntry> >::const_iterator i;
-        std::vector<SharedHandle<FileEntry> >::const_iterator eoi
+        std::vector<std::shared_ptr<FileEntry> >::const_iterator i;
+        std::vector<std::shared_ptr<FileEntry> >::const_iterator eoi
           = dctx->getFileEntries().end();
         for(i = dctx->getFileEntries().begin(); i != eoi; ++i) {
           if((*i)->getRemainingUris().empty()) {
diff --git a/src/Metalink2RequestGroup.h b/src/Metalink2RequestGroup.h
index c8d60c4b..9b2574ac 100644
--- a/src/Metalink2RequestGroup.h
+++ b/src/Metalink2RequestGroup.h
@@ -38,8 +38,8 @@
 #include "common.h"
 #include <string>
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "A2STR.h"
 
 namespace aria2 {
@@ -52,20 +52,20 @@ class MetalinkEntry;
 class Metalink2RequestGroup {
 private:
   void
-  createRequestGroup(std::vector<SharedHandle<RequestGroup> >& groups,
-                     const std::vector<SharedHandle<MetalinkEntry> >& entries,
-                     const SharedHandle<Option>& option);
+  createRequestGroup(std::vector<std::shared_ptr<RequestGroup> >& groups,
+                     const std::vector<std::shared_ptr<MetalinkEntry> >& entries,
+                     const std::shared_ptr<Option>& option);
 public:
   Metalink2RequestGroup();
 
-  void generate(std::vector<SharedHandle<RequestGroup> >& groups,
+  void generate(std::vector<std::shared_ptr<RequestGroup> >& groups,
                 const std::string& metalinkFile,
-                const SharedHandle<Option>& option,
+                const std::shared_ptr<Option>& option,
                 const std::string& baseUri = A2STR::NIL);
 
-  void generate(std::vector<SharedHandle<RequestGroup> >& groups,
-                const SharedHandle<BinaryStream>& binaryStream,
-                const SharedHandle<Option>& option,
+  void generate(std::vector<std::shared_ptr<RequestGroup> >& groups,
+                const std::shared_ptr<BinaryStream>& binaryStream,
+                const std::shared_ptr<Option>& option,
                 const std::string& baseUri = A2STR::NIL);
 };
 
diff --git a/src/MetalinkEntry.cc b/src/MetalinkEntry.cc
index ee1008a4..e41b5d44 100644
--- a/src/MetalinkEntry.cc
+++ b/src/MetalinkEntry.cc
@@ -70,7 +70,7 @@ public:
     std::sort(locations_.begin(), locations_.end());
   }
 
-  void operator()(SharedHandle<MetalinkResource>& res) {
+  void operator()(std::shared_ptr<MetalinkResource>& res) {
     if(std::binary_search
        (locations_.begin(), locations_.end(), res->location)) {
       res->priority += priorityToAdd_;
@@ -122,7 +122,7 @@ public:
   AddProtocolPriority(const std::string& protocol, int prefToAdd):
     protocol_(protocol), priorityToAdd_(prefToAdd) {}
 
-  void operator()(const SharedHandle<MetalinkResource>& res) const
+  void operator()(const std::shared_ptr<MetalinkResource>& res) const
   {
     if(protocol_ == MetalinkResource::getTypeString(res->type)) {
       res->priority += priorityToAdd_;
@@ -142,8 +142,8 @@ namespace {
 template<typename T>
 class PriorityHigher {
 public:
-  bool operator()(const SharedHandle<T>& res1,
-                  const SharedHandle<T>& res2)
+  bool operator()(const std::shared_ptr<T>& res1,
+                  const std::shared_ptr<T>& res2)
   {
     return res1->priority < res2->priority;
   }
@@ -163,9 +163,9 @@ void MetalinkEntry::reorderMetaurlsByPriority()
 }
 
 namespace {
-class Supported:public std::unary_function<SharedHandle<MetalinkResource>, bool> {
+class Supported:public std::unary_function<std::shared_ptr<MetalinkResource>, bool> {
 public:
-  bool operator()(const SharedHandle<MetalinkResource>& res) const
+  bool operator()(const std::shared_ptr<MetalinkResource>& res) const
   {
     switch(res->type) {
     case MetalinkResource::TYPE_FTP:
@@ -191,15 +191,15 @@ void MetalinkEntry::dropUnsupportedResource() {
 }
 
 void MetalinkEntry::toFileEntry
-(std::vector<SharedHandle<FileEntry> >& fileEntries,
- const std::vector<SharedHandle<MetalinkEntry> >& metalinkEntries)
+(std::vector<std::shared_ptr<FileEntry> >& fileEntries,
+ const std::vector<std::shared_ptr<MetalinkEntry> >& metalinkEntries)
 {
   std::transform(metalinkEntries.begin(), metalinkEntries.end(),
                  std::back_inserter(fileEntries),
                  mem_fun_sh(&MetalinkEntry::getFile));
 }
 
-void MetalinkEntry::setSignature(const SharedHandle<Signature>& signature)
+void MetalinkEntry::setSignature(const std::shared_ptr<Signature>& signature)
 {
   signature_ = signature;
 }
diff --git a/src/MetalinkEntry.h b/src/MetalinkEntry.h
index fa15aaac..475efe0d 100644
--- a/src/MetalinkEntry.h
+++ b/src/MetalinkEntry.h
@@ -39,8 +39,7 @@
 
 #include <string>
 #include <vector>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -55,21 +54,21 @@ class Signature;
 
 class MetalinkEntry {
 public:
-  SharedHandle<FileEntry> file;
+  std::shared_ptr<FileEntry> file;
   std::string version;
   std::vector<std::string> languages;
   std::vector<std::string> oses;
   // True if size is specified in Metalink document.
   bool sizeKnown;
-  std::vector<SharedHandle<MetalinkResource> > resources;
-  std::vector<SharedHandle<MetalinkMetaurl> > metaurls;
+  std::vector<std::shared_ptr<MetalinkResource> > resources;
+  std::vector<std::shared_ptr<MetalinkMetaurl> > metaurls;
   int maxConnections; // Metalink3Spec
 #ifdef ENABLE_MESSAGE_DIGEST
-  SharedHandle<Checksum> checksum;
-  SharedHandle<ChunkChecksum> chunkChecksum;
+  std::shared_ptr<Checksum> checksum;
+  std::shared_ptr<ChunkChecksum> chunkChecksum;
 #endif // ENABLE_MESSAGE_DIGEST
 private:
-  SharedHandle<Signature> signature_;
+  std::shared_ptr<Signature> signature_;
 public:
   MetalinkEntry();
 
@@ -81,7 +80,7 @@ public:
 
   int64_t getLength() const;
 
-  const SharedHandle<FileEntry>& getFile() const
+  const std::shared_ptr<FileEntry>& getFile() const
   {
     return file;
   }
@@ -102,12 +101,12 @@ public:
   void setProtocolPriority(const std::string& protocol, int priorityToAdd);
 
   static void toFileEntry
-  (std::vector<SharedHandle<FileEntry> >& fileEntries,
-   const std::vector<SharedHandle<MetalinkEntry> >& metalinkEntries);
+  (std::vector<std::shared_ptr<FileEntry> >& fileEntries,
+   const std::vector<std::shared_ptr<MetalinkEntry> >& metalinkEntries);
 
-  void setSignature(const SharedHandle<Signature>& signature);
+  void setSignature(const std::shared_ptr<Signature>& signature);
 
-  const SharedHandle<Signature>& getSignature() const
+  const std::shared_ptr<Signature>& getSignature() const
   {
     return signature_;
   }
diff --git a/src/MetalinkParserController.cc b/src/MetalinkParserController.cc
index 762aa81d..187e6cc1 100644
--- a/src/MetalinkParserController.cc
+++ b/src/MetalinkParserController.cc
@@ -237,7 +237,7 @@ void MetalinkParserController::commitResourceTransaction()
   }
 #ifdef ENABLE_BITTORRENT
   if(tResource_->type == MetalinkResource::TYPE_BITTORRENT) {
-    SharedHandle<MetalinkMetaurl> metaurl(new MetalinkMetaurl());
+    std::shared_ptr<MetalinkMetaurl> metaurl(new MetalinkMetaurl());
     metaurl->url = tResource_->url;
     metaurl->priority = tResource_->priority;
     metaurl->mediatype = MetalinkMetaurl::MEDIATYPE_TORRENT;
diff --git a/src/MetalinkParserController.h b/src/MetalinkParserController.h
index e640a71e..c3bd537a 100644
--- a/src/MetalinkParserController.h
+++ b/src/MetalinkParserController.h
@@ -40,8 +40,7 @@
 #include <string>
 #include <utility>
 #include <vector>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -58,21 +57,21 @@ class ChunkChecksum;
 
 class MetalinkParserController {
 private:
-  SharedHandle<Metalinker> metalinker_;
+  std::shared_ptr<Metalinker> metalinker_;
 
-  SharedHandle<MetalinkEntry> tEntry_;
+  std::shared_ptr<MetalinkEntry> tEntry_;
 
-  SharedHandle<MetalinkResource> tResource_;
+  std::shared_ptr<MetalinkResource> tResource_;
 
-  SharedHandle<MetalinkMetaurl> tMetaurl_;
+  std::shared_ptr<MetalinkMetaurl> tMetaurl_;
 #ifdef ENABLE_MESSAGE_DIGEST
-  SharedHandle<Checksum> tChecksum_;
+  std::shared_ptr<Checksum> tChecksum_;
 
-  SharedHandle<ChunkChecksum> tChunkChecksumV4_; // Metalink4Spec
+  std::shared_ptr<ChunkChecksum> tChunkChecksumV4_; // Metalink4Spec
 
   std::vector<std::string> tempChunkChecksumsV4_; // Metalink4Spec
 
-  SharedHandle<ChunkChecksum> tChunkChecksum_; // Metalink3Spec
+  std::shared_ptr<ChunkChecksum> tChunkChecksum_; // Metalink3Spec
 
   std::vector<std::pair<size_t, std::string> > tempChunkChecksums_;//Metalink3Spec
 
@@ -80,7 +79,7 @@ private:
 
 #endif // ENABLE_MESSAGE_DIGEST
 
-  SharedHandle<Signature> tSignature_;
+  std::shared_ptr<Signature> tSignature_;
   std::string baseUri_;
 public:
   MetalinkParserController();
@@ -89,7 +88,7 @@ public:
 
   void reset();
 
-  const SharedHandle<Metalinker>& getResult() const
+  const std::shared_ptr<Metalinker>& getResult() const
   {
     return metalinker_;
   }
diff --git a/src/MetalinkParserStateImpl.cc b/src/MetalinkParserStateImpl.cc
index b61d8f57..bcc76029 100644
--- a/src/MetalinkParserStateImpl.cc
+++ b/src/MetalinkParserStateImpl.cc
@@ -35,6 +35,7 @@
 #include "MetalinkParserStateImpl.h"
 
 #include <cstring>
+#include <algorithm>
 
 #include "MetalinkParserStateV3Impl.h"
 #include "MetalinkParserStateV4Impl.h"
diff --git a/src/MetalinkParserStateMachine.h b/src/MetalinkParserStateMachine.h
index 8beed5ea..0414a4ac 100644
--- a/src/MetalinkParserStateMachine.h
+++ b/src/MetalinkParserStateMachine.h
@@ -40,8 +40,8 @@
 #include <string>
 #include <vector>
 #include <stack>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "MetalinkParserController.h"
 #include "MetalinkParserState.h"
 
@@ -51,7 +51,7 @@ class Metalinker;
 
 class MetalinkParserStateMachine : public ParserStateMachine {
 private:
-  SharedHandle<MetalinkParserController> ctrl_;
+  std::shared_ptr<MetalinkParserController> ctrl_;
 
   std::stack<MetalinkParserState*> stateStack_;
 
@@ -265,7 +265,7 @@ public:
 
   std::string getErrorString() const;
 
-  const SharedHandle<Metalinker>& getResult() const
+  const std::shared_ptr<Metalinker>& getResult() const
   {
     return ctrl_->getResult();
   }
diff --git a/src/MetalinkPostDownloadHandler.cc b/src/MetalinkPostDownloadHandler.cc
index 44f794cf..fbd47030 100644
--- a/src/MetalinkPostDownloadHandler.cc
+++ b/src/MetalinkPostDownloadHandler.cc
@@ -56,7 +56,7 @@ namespace aria2 {
 
 MetalinkPostDownloadHandler::MetalinkPostDownloadHandler()
 {
-  SharedHandle<RequestGroupCriteria> cri
+  std::shared_ptr<RequestGroupCriteria> cri
     (new ContentTypeRequestGroupCriteria
      (getMetalinkContentTypes(), getMetalinkExtensions()));
   setCriteria(cri);
@@ -67,13 +67,13 @@ MetalinkPostDownloadHandler::~MetalinkPostDownloadHandler() {}
 namespace {
 const std::string& getBaseUri(RequestGroup* requestGroup)
 {
-  const SharedHandle<DownloadContext>& dctx =
+  const std::shared_ptr<DownloadContext>& dctx =
     requestGroup->getDownloadContext();
   if(dctx->getFileEntries().empty()) {
     return A2STR::NIL;
   } else {
     // TODO Check download result for each URI
-    const SharedHandle<FileEntry>& entry = dctx->getFirstFileEntry();
+    const std::shared_ptr<FileEntry>& entry = dctx->getFirstFileEntry();
     const std::deque<std::string>& spentUris = entry->getSpentUris();
     if(spentUris.empty()) {
       const std::deque<std::string>& remainingUris = entry->getRemainingUris();
@@ -90,22 +90,22 @@ const std::string& getBaseUri(RequestGroup* requestGroup)
 } // namespace
 
 void MetalinkPostDownloadHandler::getNextRequestGroups
-(std::vector<SharedHandle<RequestGroup> >& groups,
+(std::vector<std::shared_ptr<RequestGroup> >& groups,
  RequestGroup* requestGroup)
 {
   A2_LOG_DEBUG(fmt("Generating RequestGroups for Metalink file %s",
                    requestGroup->getFirstFilePath().c_str()));
-  SharedHandle<DiskAdaptor> diskAdaptor =
+  std::shared_ptr<DiskAdaptor> diskAdaptor =
     requestGroup->getPieceStorage()->getDiskAdaptor();
   try {
     diskAdaptor->openExistingFile();
     //requestOption.put(PREF_DIR, requestGroup->getDownloadContext()->getDir());
     const std::string& baseUri = getBaseUri(requestGroup);
-    std::vector<SharedHandle<RequestGroup> > newRgs;
+    std::vector<std::shared_ptr<RequestGroup> > newRgs;
     Metalink2RequestGroup().generate(newRgs, diskAdaptor,
                                      requestGroup->getOption(), baseUri);
     requestGroup->followedBy(newRgs.begin(), newRgs.end());
-    SharedHandle<MetadataInfo> mi =
+    std::shared_ptr<MetadataInfo> mi =
       createMetadataInfoFromFirstFileEntry(requestGroup->getGroupId(),
                                            requestGroup->getDownloadContext());
     if(mi) {
diff --git a/src/MetalinkPostDownloadHandler.h b/src/MetalinkPostDownloadHandler.h
index bdb89e54..1f975ea7 100644
--- a/src/MetalinkPostDownloadHandler.h
+++ b/src/MetalinkPostDownloadHandler.h
@@ -47,7 +47,7 @@ public:
   virtual ~MetalinkPostDownloadHandler();
 
   virtual void
-  getNextRequestGroups(std::vector<SharedHandle<RequestGroup> >& groups,
+  getNextRequestGroups(std::vector<std::shared_ptr<RequestGroup> >& groups,
                        RequestGroup* requestGroup);
 };
 
diff --git a/src/Metalinker.cc b/src/Metalinker.cc
index 435c81e5..70e8fcfa 100644
--- a/src/Metalinker.cc
+++ b/src/Metalinker.cc
@@ -45,7 +45,7 @@ Metalinker::~Metalinker() {}
 
 namespace {
 class EntryQuery:
-    public std::unary_function<SharedHandle<MetalinkEntry>, bool> {
+    public std::unary_function<std::shared_ptr<MetalinkEntry>, bool> {
 private:
   std::string version;
   std::string language;
@@ -58,7 +58,7 @@ public:
     language(language),
     os(os) {}
 
-  bool operator()(const SharedHandle<MetalinkEntry>& entry) const {
+  bool operator()(const std::shared_ptr<MetalinkEntry>& entry) const {
     if(!version.empty()) {
       if(version != entry->version) {
         return false;
@@ -80,7 +80,7 @@ public:
 } // namespace
 
 void Metalinker::queryEntry
-(std::vector<SharedHandle<MetalinkEntry> >& queryResult,
+(std::vector<std::shared_ptr<MetalinkEntry> >& queryResult,
  const std::string& version,
  const std::string& language,
  const std::string& os) const
@@ -90,7 +90,7 @@ void Metalinker::queryEntry
                       std::not1(EntryQuery(version, language, os)));
 }
 
-void Metalinker::addEntry(const SharedHandle<MetalinkEntry>& entry)
+void Metalinker::addEntry(const std::shared_ptr<MetalinkEntry>& entry)
 {
   entries_.push_back(entry);
 }
diff --git a/src/Metalinker.h b/src/Metalinker.h
index b6399d34..6e2726d9 100644
--- a/src/Metalinker.h
+++ b/src/Metalinker.h
@@ -39,8 +39,7 @@
 
 #include <string>
 #include <vector>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -48,7 +47,7 @@ class MetalinkEntry;
 
 class Metalinker {
 private:
-  std::vector<SharedHandle<MetalinkEntry> > entries_;
+  std::vector<std::shared_ptr<MetalinkEntry> > entries_;
 public:
   Metalinker();
   ~Metalinker();
@@ -58,17 +57,17 @@ public:
   Metalinker& operator=(const Metalinker&);
 
   void queryEntry
-  (std::vector<SharedHandle<MetalinkEntry> >& queryResult,
+  (std::vector<std::shared_ptr<MetalinkEntry> >& queryResult,
    const std::string& version,
    const std::string& language,
    const std::string& os) const;
 
-  const std::vector<SharedHandle<MetalinkEntry> >& getEntries() const
+  const std::vector<std::shared_ptr<MetalinkEntry> >& getEntries() const
   {
     return entries_;
   }
 
-  void addEntry(const SharedHandle<MetalinkEntry>& entry);
+  void addEntry(const std::shared_ptr<MetalinkEntry>& entry);
 };
 
 } // namespace aria2
diff --git a/src/MultiDiskAdaptor.cc b/src/MultiDiskAdaptor.cc
index dcc46bcb..4bdbab03 100644
--- a/src/MultiDiskAdaptor.cc
+++ b/src/MultiDiskAdaptor.cc
@@ -54,7 +54,7 @@
 
 namespace aria2 {
 
-DiskWriterEntry::DiskWriterEntry(const SharedHandle<FileEntry>& fileEntry)
+DiskWriterEntry::DiskWriterEntry(const std::shared_ptr<FileEntry>& fileEntry)
   : fileEntry_(fileEntry),
     open_(false),
     needsFileAllocation_(false)
@@ -107,7 +107,7 @@ int64_t DiskWriterEntry::size() const
   return File(getFilePath()).size();
 }
 
-void DiskWriterEntry::setDiskWriter(const SharedHandle<DiskWriter>& diskWriter)
+void DiskWriterEntry::setDiskWriter(const std::shared_ptr<DiskWriter>& diskWriter)
 {
   diskWriter_ = diskWriter;
 }
@@ -126,11 +126,11 @@ MultiDiskAdaptor::MultiDiskAdaptor()
 MultiDiskAdaptor::~MultiDiskAdaptor() {}
 
 namespace {
-SharedHandle<DiskWriterEntry> createDiskWriterEntry
-(const SharedHandle<FileEntry>& fileEntry,
+std::shared_ptr<DiskWriterEntry> createDiskWriterEntry
+(const std::shared_ptr<FileEntry>& fileEntry,
  bool needsFileAllocation)
 {
-  SharedHandle<DiskWriterEntry> entry(new DiskWriterEntry(fileEntry));
+  std::shared_ptr<DiskWriterEntry> entry(new DiskWriterEntry(fileEntry));
   entry->needsFileAllocation(needsFileAllocation);
   return entry;
 }
@@ -144,7 +144,7 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
     return;
   }
 
-  for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
+  for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i =
         getFileEntries().begin(), eoi = getFileEntries().end(); i != eoi; ++i) {
     diskWriterEntries_.push_back
       (createDiskWriterEntry(*i, (*i)->isRequested()));
@@ -152,12 +152,12 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
   std::map<std::string, bool> dwreq;
   // TODO Currently, pieceLength_ == 0 is used for unit testing only.
   if(pieceLength_ > 0) {
-    std::vector<SharedHandle<DiskWriterEntry> >::const_iterator done =
+    std::vector<std::shared_ptr<DiskWriterEntry> >::const_iterator done =
       diskWriterEntries_.begin();
-    for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator itr =
+    for(std::vector<std::shared_ptr<DiskWriterEntry> >::const_iterator itr =
           diskWriterEntries_.begin(), eoi = diskWriterEntries_.end();
         itr != eoi;) {
-      const SharedHandle<FileEntry>& fileEntry = (*itr)->getFileEntry();
+      const std::shared_ptr<FileEntry>& fileEntry = (*itr)->getFileEntry();
 
       if(!fileEntry->isRequested()) {
         ++itr;
@@ -166,9 +166,9 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
       int64_t pieceStartOffset =
         (fileEntry->getOffset()/pieceLength_)*pieceLength_;
       if(itr != diskWriterEntries_.begin()) {
-        for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator i =
+        for(std::vector<std::shared_ptr<DiskWriterEntry> >::const_iterator i =
               itr-1; true; --i) {
-          const SharedHandle<FileEntry>& fileEntry = (*i)->getFileEntry();
+          const std::shared_ptr<FileEntry>& fileEntry = (*i)->getFileEntry();
           if(pieceStartOffset <= fileEntry->getOffset() ||
              pieceStartOffset < fileEntry->getLastOffset()) {
             (*i)->needsFileAllocation(true);
@@ -218,7 +218,7 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
     }
   }
   DefaultDiskWriterFactory dwFactory;
-  for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator i =
+  for(std::vector<std::shared_ptr<DiskWriterEntry> >::const_iterator i =
         diskWriterEntries_.begin(), eoi = diskWriterEntries_.end();
       i != eoi; ++i) {
     if((*i)->needsFileAllocation() ||
@@ -237,7 +237,7 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
 }
 
 void MultiDiskAdaptor::openIfNot
-(const SharedHandle<DiskWriterEntry>& entry, void (DiskWriterEntry::*open)())
+(const std::shared_ptr<DiskWriterEntry>& entry, void (DiskWriterEntry::*open)())
 {
   if(!entry->isOpen()) {
     //     A2_LOG_DEBUG(fmt("DiskWriterEntry: Cache MISS. offset=%s",
@@ -250,7 +250,7 @@ void MultiDiskAdaptor::openIfNot
       // Choose one DiskWriterEntry randomly and close it.
       size_t index =
         SimpleRandomizer::getInstance()->getRandomNumber(numOpened);
-      std::vector<SharedHandle<DiskWriterEntry> >::iterator i =
+      std::vector<std::shared_ptr<DiskWriterEntry> >::iterator i =
         openedDiskWriterEntries_.begin();
       std::advance(i, index);
       (*i)->closeFile();
@@ -304,7 +304,7 @@ void MultiDiskAdaptor::closeFile()
 }
 
 namespace {
-bool isInRange(const SharedHandle<DiskWriterEntry> entry, int64_t offset)
+bool isInRange(const std::shared_ptr<DiskWriterEntry> entry, int64_t offset)
 {
   return entry->getFileEntry()->getOffset() <= offset &&
     offset < entry->getFileEntry()->getLastOffset();
@@ -312,7 +312,7 @@ bool isInRange(const SharedHandle<DiskWriterEntry> entry, int64_t offset)
 } // namespace
 
 namespace {
-ssize_t calculateLength(const SharedHandle<DiskWriterEntry> entry,
+ssize_t calculateLength(const std::shared_ptr<DiskWriterEntry> entry,
                         int64_t fileOffset, ssize_t rem)
 {
   if(entry->getFileEntry()->getLength() < fileOffset+rem) {
@@ -326,7 +326,7 @@ ssize_t calculateLength(const SharedHandle<DiskWriterEntry> entry,
 namespace {
 class OffsetCompare {
 public:
-  bool operator()(int64_t offset, const SharedHandle<DiskWriterEntry>& dwe)
+  bool operator()(int64_t offset, const std::shared_ptr<DiskWriterEntry>& dwe)
   {
     return offset < dwe->getFileEntry()->getOffset();
   }
@@ -353,7 +353,7 @@ DiskWriterEntries::const_iterator findFirstDiskWriterEntry
 } // namespace
 
 namespace {
-void throwOnDiskWriterNotOpened(const SharedHandle<DiskWriterEntry>& e,
+void throwOnDiskWriterNotOpened(const std::shared_ptr<DiskWriterEntry>& e,
                                 int64_t offset)
 {
   throw DL_ABORT_EX
@@ -439,7 +439,7 @@ void MultiDiskAdaptor::writeCache(const WrDiskCacheEntry* entry)
   size_t celloff = 0;
   for(; dent != eod; ++dent) {
     int64_t lstart = 0, lp = 0;
-    const SharedHandle<FileEntry>& fent = (*dent)->getFileEntry();
+    const std::shared_ptr<FileEntry>& fent = (*dent)->getFileEntry();
     for(; i != eoi;) {
       if(std::max(fent->getOffset(),
                   static_cast<int64_t>((*i)->goff + celloff)) <
@@ -450,7 +450,7 @@ void MultiDiskAdaptor::writeCache(const WrDiskCacheEntry* entry)
           throwOnDiskWriterNotOpened(*dent, (*i)->goff + celloff);
         }
       } else {
-        A2_LOG_DEBUG(fmt("%s Cache flush loff=%"PRId64", len=%lu",
+        A2_LOG_DEBUG(fmt("%s Cache flush loff=%" PRId64 ", len=%lu",
                          fent->getPath().c_str(),
                          lstart,
                          static_cast<unsigned long>(buflen-buffoffset)));
@@ -461,7 +461,7 @@ void MultiDiskAdaptor::writeCache(const WrDiskCacheEntry* entry)
       }
       int64_t loff = fent->gtoloff((*i)->goff + celloff);
       if(static_cast<int64_t>(lstart + buflen) < loff) {
-        A2_LOG_DEBUG(fmt("%s Cache flush loff=%"PRId64", len=%lu",
+        A2_LOG_DEBUG(fmt("%s Cache flush loff=%" PRId64 ", len=%lu",
                          fent->getPath().c_str(),
                          lstart,
                          static_cast<unsigned long>(buflen-buffoffset)));
@@ -485,7 +485,7 @@ void MultiDiskAdaptor::writeCache(const WrDiskCacheEntry* entry)
         celloff += wlen;
         lp += wlen;
         if(lp == fent->getLength() || buflen == sizeof(buf)) {
-          A2_LOG_DEBUG(fmt("%s Cache flush loff=%"PRId64", len=%lu",
+          A2_LOG_DEBUG(fmt("%s Cache flush loff=%" PRId64 ", len=%lu",
                            fent->getPath().c_str(),
                            lstart,
                            static_cast<unsigned long>(buflen-buffoffset)));
@@ -505,7 +505,7 @@ void MultiDiskAdaptor::writeCache(const WrDiskCacheEntry* entry)
       }
     }
     if(i == eoi) {
-      A2_LOG_DEBUG(fmt("%s Cache flush loff=%"PRId64", len=%lu",
+      A2_LOG_DEBUG(fmt("%s Cache flush loff=%" PRId64 ", len=%lu",
                        fent->getPath().c_str(),
                        lstart,
                        static_cast<unsigned long>(buflen - buffoffset)));
@@ -527,16 +527,16 @@ bool MultiDiskAdaptor::fileExists()
 int64_t MultiDiskAdaptor::size()
 {
   int64_t size = 0;
-  for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
+  for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i =
         getFileEntries().begin(), eoi = getFileEntries().end(); i != eoi; ++i) {
     size += File((*i)->getPath()).size();
   }
   return size;
 }
 
-SharedHandle<FileAllocationIterator> MultiDiskAdaptor::fileAllocationIterator()
+std::shared_ptr<FileAllocationIterator> MultiDiskAdaptor::fileAllocationIterator()
 {
-  return SharedHandle<FileAllocationIterator>
+  return std::shared_ptr<FileAllocationIterator>
     (new MultiFileAllocationIterator(this));
 }
 
@@ -552,10 +552,10 @@ void MultiDiskAdaptor::disableReadOnly()
 
 void MultiDiskAdaptor::enableMmap()
 {
-  for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator i =
+  for(std::vector<std::shared_ptr<DiskWriterEntry> >::const_iterator i =
         diskWriterEntries_.begin(), eoi = diskWriterEntries_.end();
       i != eoi; ++i) {
-    const SharedHandle<DiskWriter>& dw = (*i)->getDiskWriter();
+    const std::shared_ptr<DiskWriter>& dw = (*i)->getDiskWriter();
     if(dw) {
       dw->enableMmap();
     }
@@ -564,7 +564,7 @@ void MultiDiskAdaptor::enableMmap()
 
 void MultiDiskAdaptor::cutTrailingGarbage()
 {
-  for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator i =
+  for(std::vector<std::shared_ptr<DiskWriterEntry> >::const_iterator i =
         diskWriterEntries_.begin(), eoi = diskWriterEntries_.end();
       i != eoi; ++i) {
     int64_t length = (*i)->getFileEntry()->getLength();
@@ -584,7 +584,7 @@ void MultiDiskAdaptor::setMaxOpenFiles(int maxOpenFiles)
 size_t MultiDiskAdaptor::utime(const Time& actime, const Time& modtime)
 {
   size_t numOK = 0;
-  for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
+  for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i =
         getFileEntries().begin(), eoi = getFileEntries().end(); i != eoi; ++i) {
     if((*i)->isRequested()) {
       File f((*i)->getPath());
diff --git a/src/MultiDiskAdaptor.h b/src/MultiDiskAdaptor.h
index 545c993b..f778f9d8 100644
--- a/src/MultiDiskAdaptor.h
+++ b/src/MultiDiskAdaptor.h
@@ -45,12 +45,12 @@ class DiskWriter;
 
 class DiskWriterEntry {
 private:
-  SharedHandle<FileEntry> fileEntry_;
-  SharedHandle<DiskWriter> diskWriter_;
+  std::shared_ptr<FileEntry> fileEntry_;
+  std::shared_ptr<DiskWriter> diskWriter_;
   bool open_;
   bool needsFileAllocation_;
 public:
-  DiskWriterEntry(const SharedHandle<FileEntry>& fileEntry);
+  DiskWriterEntry(const std::shared_ptr<FileEntry>& fileEntry);
 
   const std::string& getFilePath() const;
 
@@ -71,14 +71,14 @@ public:
 
   int64_t size() const;
 
-  const SharedHandle<FileEntry>& getFileEntry() const
+  const std::shared_ptr<FileEntry>& getFileEntry() const
   {
     return fileEntry_;
   }
 
-  void setDiskWriter(const SharedHandle<DiskWriter>& diskWriter);
+  void setDiskWriter(const std::shared_ptr<DiskWriter>& diskWriter);
 
-  const SharedHandle<DiskWriter>& getDiskWriter() const
+  const std::shared_ptr<DiskWriter>& getDiskWriter() const
   {
     return diskWriter_;
   }
@@ -97,7 +97,7 @@ public:
 
 };
 
-typedef std::vector<SharedHandle<DiskWriterEntry> > DiskWriterEntries;
+typedef std::vector<std::shared_ptr<DiskWriterEntry> > DiskWriterEntries;
 
 class MultiDiskAdaptor : public DiskAdaptor {
   friend class MultiFileAllocationIterator;
@@ -105,7 +105,7 @@ private:
   int32_t pieceLength_;
   DiskWriterEntries diskWriterEntries_;
 
-  std::vector<SharedHandle<DiskWriterEntry> > openedDiskWriterEntries_;
+  std::vector<std::shared_ptr<DiskWriterEntry> > openedDiskWriterEntries_;
 
   int maxOpenFiles_;
 
@@ -113,7 +113,7 @@ private:
 
   void resetDiskWriterEntries();
 
-  void openIfNot(const SharedHandle<DiskWriterEntry>& entry,
+  void openIfNot(const std::shared_ptr<DiskWriterEntry>& entry,
                  void (DiskWriterEntry::*f)());
 
   static const int DEFAULT_MAX_OPEN_FILES = 100;
@@ -141,7 +141,7 @@ public:
 
   virtual int64_t size();
 
-  virtual SharedHandle<FileAllocationIterator> fileAllocationIterator();
+  virtual std::shared_ptr<FileAllocationIterator> fileAllocationIterator();
 
   virtual void enableReadOnly();
 
@@ -168,7 +168,7 @@ public:
 
   virtual size_t utime(const Time& actime, const Time& modtime);
 
-  const std::vector<SharedHandle<DiskWriterEntry> >&
+  const std::vector<std::shared_ptr<DiskWriterEntry> >&
   getDiskWriterEntries() const
   {
     return diskWriterEntries_;
diff --git a/src/MultiFileAllocationIterator.cc b/src/MultiFileAllocationIterator.cc
index 58e4b22a..b2561e10 100644
--- a/src/MultiFileAllocationIterator.cc
+++ b/src/MultiFileAllocationIterator.cc
@@ -60,9 +60,9 @@ void MultiFileAllocationIterator::allocateChunk()
     if(entries_.empty()) {
       break;
     }
-    SharedHandle<DiskWriterEntry> entry = entries_.front();
+    std::shared_ptr<DiskWriterEntry> entry = entries_.front();
     entries_.pop_front();
-    SharedHandle<FileEntry> fileEntry = entry->getFileEntry();
+    std::shared_ptr<FileEntry> fileEntry = entry->getFileEntry();
     // Open file before calling DiskWriterEntry::size()
     diskAdaptor_->openIfNot(entry, &DiskWriterEntry::openFile);
     if(entry->needsFileAllocation() && entry->size() < fileEntry->getLength()) {
@@ -121,7 +121,7 @@ int64_t MultiFileAllocationIterator::getTotalLength()
   }
 }
 
-const std::deque<SharedHandle<DiskWriterEntry> >&
+const std::deque<std::shared_ptr<DiskWriterEntry> >&
 MultiFileAllocationIterator::getDiskWriterEntries() const
 {
   return entries_;
diff --git a/src/MultiFileAllocationIterator.h b/src/MultiFileAllocationIterator.h
index 28713d7f..8780c8d1 100644
--- a/src/MultiFileAllocationIterator.h
+++ b/src/MultiFileAllocationIterator.h
@@ -36,7 +36,9 @@
 #define D_MULTI_FILE_ALLOCATION_ITERATOR_H
 
 #include "FileAllocationIterator.h"
+
 #include <deque>
+#include <memory>
 
 namespace aria2 {
 
@@ -47,8 +49,8 @@ class MultiFileAllocationIterator:public FileAllocationIterator
 {
 private:
   MultiDiskAdaptor* diskAdaptor_;
-  std::deque<SharedHandle<DiskWriterEntry> > entries_;
-  SharedHandle<FileAllocationIterator> fileAllocationIterator_;
+  std::deque<std::shared_ptr<DiskWriterEntry> > entries_;
+  std::shared_ptr<FileAllocationIterator> fileAllocationIterator_;
 public:
   MultiFileAllocationIterator(MultiDiskAdaptor* diskAdaptor);
 
@@ -62,7 +64,7 @@ public:
 
   virtual int64_t getTotalLength();
 
-  const std::deque<SharedHandle<DiskWriterEntry> >&
+  const std::deque<std::shared_ptr<DiskWriterEntry> >&
   getDiskWriterEntries() const;
 };
 
diff --git a/src/MultiUrlRequestInfo.cc b/src/MultiUrlRequestInfo.cc
index 655a66e4..c7839acf 100644
--- a/src/MultiUrlRequestInfo.cc
+++ b/src/MultiUrlRequestInfo.cc
@@ -104,11 +104,11 @@ void handler(int signal) {
 } // namespace
 
 MultiUrlRequestInfo::MultiUrlRequestInfo
-(std::vector<SharedHandle<RequestGroup> >& requestGroups,
- const SharedHandle<Option>& op,
- const SharedHandle<StatCalc>& statCalc,
- const SharedHandle<OutputFile>& summaryOut,
- const SharedHandle<UriListParser>& uriListParser)
+(std::vector<std::shared_ptr<RequestGroup> >& requestGroups,
+ const std::shared_ptr<Option>& op,
+ const std::shared_ptr<StatCalc>& statCalc,
+ const std::shared_ptr<OutputFile>& summaryOut,
+ const std::shared_ptr<UriListParser>& uriListParser)
   : option_(op),
     statCalc_(statCalc),
     summaryOut_(summaryOut),
@@ -137,7 +137,7 @@ int MultiUrlRequestInfo::prepare()
 {
   global::globalHaltRequested = 0;
   try {
-    SharedHandle<Notifier> notifier(new Notifier());
+    std::shared_ptr<Notifier> notifier(new Notifier());
     SingletonHolder<Notifier>::instance(notifier);
 
 #ifdef ENABLE_SSL
@@ -150,7 +150,7 @@ int MultiUrlRequestInfo::prepare()
          ) {
         // We set server TLS context to the SocketCore before creating
         // DownloadEngine instance.
-        SharedHandle<TLSContext> svTlsContext(TLSContext::make(TLS_SERVER));
+        std::shared_ptr<TLSContext> svTlsContext(TLSContext::make(TLS_SERVER));
         svTlsContext->addCredentialFile(option_->get(PREF_RPC_CERTIFICATE),
                                         option_->get(PREF_RPC_PRIVATE_KEY));
         SocketCore::setServerTLSContext(svTlsContext);
@@ -168,7 +168,7 @@ int MultiUrlRequestInfo::prepare()
 
 #ifdef ENABLE_WEBSOCKET
     if(option_->getAsBool(PREF_ENABLE_RPC)) {
-      SharedHandle<rpc::WebSocketSessionMan> wsSessionMan
+      std::shared_ptr<rpc::WebSocketSessionMan> wsSessionMan
         (new rpc::WebSocketSessionMan());
       e_->setWebSocketSessionMan(wsSessionMan);
       SingletonHolder<Notifier>::instance()->addDownloadEventListener
@@ -189,7 +189,7 @@ int MultiUrlRequestInfo::prepare()
       }
     }
 
-    SharedHandle<AuthConfigFactory> authConfigFactory(new AuthConfigFactory());
+    std::shared_ptr<AuthConfigFactory> authConfigFactory(new AuthConfigFactory());
     File netrccf(option_->get(PREF_NETRC_PATH));
     if(!option_->getAsBool(PREF_NO_NETRC) && netrccf.isFile()) {
 #ifdef __MINGW32__
@@ -202,7 +202,7 @@ int MultiUrlRequestInfo::prepare()
         A2_LOG_NOTICE(fmt(MSG_INCORRECT_NETRC_PERMISSION,
                           option_->get(PREF_NETRC_PATH).c_str()));
       } else {
-        SharedHandle<Netrc> netrc(new Netrc());
+        std::shared_ptr<Netrc> netrc(new Netrc());
         netrc->parse(option_->get(PREF_NETRC_PATH));
         authConfigFactory->setNetrc(netrc);
       }
@@ -210,7 +210,7 @@ int MultiUrlRequestInfo::prepare()
     e_->setAuthConfigFactory(authConfigFactory);
 
 #ifdef ENABLE_SSL
-    SharedHandle<TLSContext> clTlsContext(TLSContext::make(TLS_CLIENT));
+    std::shared_ptr<TLSContext> clTlsContext(TLSContext::make(TLS_CLIENT));
     if(!option_->blank(PREF_CERTIFICATE) &&
        !option_->blank(PREF_PRIVATE_KEY)) {
       clTlsContext->addCredentialFile(option_->get(PREF_CERTIFICATE),
@@ -375,7 +375,7 @@ void MultiUrlRequestInfo::resetSignalHandlers()
 #endif // SIGPIPE
 }
 
-const SharedHandle<DownloadEngine>&
+const std::shared_ptr<DownloadEngine>&
 MultiUrlRequestInfo::getDownloadEngine() const
 {
   return e_;
diff --git a/src/MultiUrlRequestInfo.h b/src/MultiUrlRequestInfo.h
index 6a324af0..82850114 100644
--- a/src/MultiUrlRequestInfo.h
+++ b/src/MultiUrlRequestInfo.h
@@ -40,8 +40,8 @@
 #include <signal.h>
 
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "DownloadResult.h"
 #include "util.h"
 
@@ -56,17 +56,17 @@ class DownloadEngine;
 
 class MultiUrlRequestInfo {
 private:
-  std::vector<SharedHandle<RequestGroup> > requestGroups_;
+  std::vector<std::shared_ptr<RequestGroup> > requestGroups_;
 
-  SharedHandle<Option> option_;
+  std::shared_ptr<Option> option_;
 
-  SharedHandle<StatCalc> statCalc_;
+  std::shared_ptr<StatCalc> statCalc_;
 
-  SharedHandle<OutputFile> summaryOut_;
+  std::shared_ptr<OutputFile> summaryOut_;
 
-  SharedHandle<UriListParser> uriListParser_;
+  std::shared_ptr<UriListParser> uriListParser_;
 
-  SharedHandle<DownloadEngine> e_;
+  std::shared_ptr<DownloadEngine> e_;
 
   sigset_t mask_;
 
@@ -81,11 +81,11 @@ public:
    * requestGroups.
    */
   MultiUrlRequestInfo
-  (std::vector<SharedHandle<RequestGroup> >& requestGroups,
-   const SharedHandle<Option>& op,
-   const SharedHandle<StatCalc>& statCalc,
-   const SharedHandle<OutputFile>& summaryOut,
-   const SharedHandle<UriListParser>& uriListParser);
+  (std::vector<std::shared_ptr<RequestGroup> >& requestGroups,
+   const std::shared_ptr<Option>& op,
+   const std::shared_ptr<StatCalc>& statCalc,
+   const std::shared_ptr<OutputFile>& summaryOut,
+   const std::shared_ptr<UriListParser>& uriListParser);
 
   virtual ~MultiUrlRequestInfo();
 
@@ -107,7 +107,7 @@ public:
   // have completed.
   error_code::Value getResult();
 
-  const SharedHandle<DownloadEngine>& getDownloadEngine() const;
+  const std::shared_ptr<DownloadEngine>& getDownloadEngine() const;
 
   // Signal handlers are not prepared if false is given.
   void setUseSignalHandler(bool useSignalHandler)
diff --git a/src/NameResolveCommand.cc b/src/NameResolveCommand.cc
index f3f31912..fab43395 100644
--- a/src/NameResolveCommand.cc
+++ b/src/NameResolveCommand.cc
@@ -54,7 +54,7 @@ namespace aria2 {
 
 NameResolveCommand::NameResolveCommand
 (cuid_t cuid, DownloadEngine* e,
- const SharedHandle<UDPTrackerRequest>& req)
+ const std::shared_ptr<UDPTrackerRequest>& req)
   : Command(cuid),
     e_(e),
 #ifdef ENABLE_ASYNC_DNS
diff --git a/src/NameResolveCommand.h b/src/NameResolveCommand.h
index 5353508c..bf2e9464 100644
--- a/src/NameResolveCommand.h
+++ b/src/NameResolveCommand.h
@@ -39,8 +39,7 @@
 
 #include <string>
 #include <vector>
-
-#include "SharedHandle.h"
+#include <memory>
 
 // TODO Make this class generic.
 namespace aria2 {
@@ -56,7 +55,7 @@ private:
   DownloadEngine* e_;
 
 #ifdef ENABLE_ASYNC_DNS
-  SharedHandle<AsyncNameResolverMan> asyncNameResolverMan_;
+  std::shared_ptr<AsyncNameResolverMan> asyncNameResolverMan_;
 #endif // ENABLE_ASYNC_DNS
 
 #ifdef ENABLE_ASYNC_DNS
@@ -64,14 +63,14 @@ private:
                       const std::string& hostname);
 #endif // ENABLE_ASYNC_DNS
 
-  SharedHandle<UDPTrackerRequest> req_;
+  std::shared_ptr<UDPTrackerRequest> req_;
   void onShutdown();
   void onFailure();
   void onSuccess
   (const std::vector<std::string>& addrs, DownloadEngine* e);
 public:
   NameResolveCommand(cuid_t cuid, DownloadEngine* e,
-                     const SharedHandle<UDPTrackerRequest>& req);
+                     const std::shared_ptr<UDPTrackerRequest>& req);
 
   virtual ~NameResolveCommand();
 
diff --git a/src/Netrc.cc b/src/Netrc.cc
index cbcfc063..0c7743d5 100644
--- a/src/Netrc.cc
+++ b/src/Netrc.cc
@@ -107,7 +107,7 @@ Netrc::Netrc() {}
 
 Netrc::~Netrc() {}
 
-void Netrc::addAuthenticator(const SharedHandle<Authenticator>& authenticator)
+void Netrc::addAuthenticator(const std::shared_ptr<Authenticator>& authenticator)
 {
   authenticators_.push_back(authenticator);
 }
@@ -146,7 +146,7 @@ void Netrc::parse(const std::string& path)
     SET_ACCOUNT,
     SET_MACDEF
   };
-  SharedHandle<Authenticator> authenticator;
+  std::shared_ptr<Authenticator> authenticator;
   STATE state = GET_TOKEN;
   while(1) {
     std::string line = fp.getLine();
@@ -215,7 +215,7 @@ void Netrc::parse(const std::string& path)
   storeAuthenticator(authenticator);
 }
 
-void Netrc::storeAuthenticator(const SharedHandle<Authenticator>& authenticator)
+void Netrc::storeAuthenticator(const std::shared_ptr<Authenticator>& authenticator)
 {
   if(authenticator) {
     authenticators_.push_back(authenticator);
@@ -229,18 +229,18 @@ private:
 public:
   AuthHostMatch(const std::string& hostname):hostname(hostname) {}
 
-  bool operator()(const SharedHandle<Authenticator>& authenticator)
+  bool operator()(const std::shared_ptr<Authenticator>& authenticator)
   {
     return authenticator->match(hostname);
   }
 };
 } // namespace
 
-SharedHandle<Authenticator>
+std::shared_ptr<Authenticator>
 Netrc::findAuthenticator(const std::string& hostname) const
 {
-  SharedHandle<Authenticator> res;
-  std::vector<SharedHandle<Authenticator> >::const_iterator itr =
+  std::shared_ptr<Authenticator> res;
+  std::vector<std::shared_ptr<Authenticator> >::const_iterator itr =
     std::find_if(authenticators_.begin(), authenticators_.end(),
                  AuthHostMatch(hostname));
   if(itr != authenticators_.end()) {
diff --git a/src/Netrc.h b/src/Netrc.h
index f97a4b8b..1fd25b27 100644
--- a/src/Netrc.h
+++ b/src/Netrc.h
@@ -39,8 +39,7 @@
 
 #include <string>
 #include <vector>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -137,9 +136,9 @@ public:
 
 class Netrc {
 private:
-  std::vector<SharedHandle<Authenticator> > authenticators_;
+  std::vector<std::shared_ptr<Authenticator> > authenticators_;
 
-  void storeAuthenticator(const SharedHandle<Authenticator>& authenticator);
+  void storeAuthenticator(const std::shared_ptr<Authenticator>& authenticator);
 public:
   Netrc();
 
@@ -147,15 +146,15 @@ public:
 
   void parse(const std::string& path);
 
-  SharedHandle<Authenticator> findAuthenticator
+  std::shared_ptr<Authenticator> findAuthenticator
   (const std::string& hostname) const;
 
-  const std::vector<SharedHandle<Authenticator> >& getAuthenticators() const
+  const std::vector<std::shared_ptr<Authenticator> >& getAuthenticators() const
   {
     return authenticators_;
   }
 
-  void addAuthenticator(const SharedHandle<Authenticator>& authenticator);
+  void addAuthenticator(const std::shared_ptr<Authenticator>& authenticator);
 };
 
 } // namespace aria2
diff --git a/src/NetrcAuthResolver.cc b/src/NetrcAuthResolver.cc
index ea6d298c..04fcc9c1 100644
--- a/src/NetrcAuthResolver.cc
+++ b/src/NetrcAuthResolver.cc
@@ -40,7 +40,7 @@ namespace aria2 {
 
 NetrcAuthResolver::NetrcAuthResolver():ignoreDefault_(false) {}
 
-SharedHandle<AuthConfig>
+std::shared_ptr<AuthConfig>
 NetrcAuthResolver::resolveAuthConfig(const std::string& hostname)
 {
   if(!getUserDefinedAuthConfig()) {
@@ -50,27 +50,27 @@ NetrcAuthResolver::resolveAuthConfig(const std::string& hostname)
   }
 }
 
-SharedHandle<AuthConfig>
+std::shared_ptr<AuthConfig>
 NetrcAuthResolver::findNetrcAuthenticator(const std::string& hostname) const
 {
   if(!netrc_) {
     return getDefaultAuthConfig();
   } else {
-    SharedHandle<Authenticator> auth = netrc_->findAuthenticator(hostname);
+    std::shared_ptr<Authenticator> auth = netrc_->findAuthenticator(hostname);
     if(!auth) {
       return getDefaultAuthConfig();
     } else {
       if(ignoreDefault_ && auth->getMachine().empty()) {
         return getDefaultAuthConfig();
       } else {
-        return SharedHandle<AuthConfig>
+        return std::shared_ptr<AuthConfig>
           (new AuthConfig(auth->getLogin(), auth->getPassword()));
       }
     }
   }
 }
 
-void NetrcAuthResolver::setNetrc(const SharedHandle<Netrc>& netrc)
+void NetrcAuthResolver::setNetrc(const std::shared_ptr<Netrc>& netrc)
 {
   netrc_ = netrc;
 }
diff --git a/src/NetrcAuthResolver.h b/src/NetrcAuthResolver.h
index 84b748af..a92b5dff 100644
--- a/src/NetrcAuthResolver.h
+++ b/src/NetrcAuthResolver.h
@@ -43,21 +43,21 @@ class Netrc;
 
 class NetrcAuthResolver : public AbstractAuthResolver {
 private:
-  SharedHandle<Netrc> netrc_;
+  std::shared_ptr<Netrc> netrc_;
 
   bool ignoreDefault_;
 
-  SharedHandle<AuthConfig> findNetrcAuthenticator
+  std::shared_ptr<AuthConfig> findNetrcAuthenticator
   (const std::string& hostname) const;
 public:
   NetrcAuthResolver();
 
-  virtual SharedHandle<AuthConfig> resolveAuthConfig
+  virtual std::shared_ptr<AuthConfig> resolveAuthConfig
   (const std::string& hostname);
 
-  void setNetrc(const SharedHandle<Netrc>& netrc);
+  void setNetrc(const std::shared_ptr<Netrc>& netrc);
 
-  const SharedHandle<Netrc>& getNetrc() const
+  const std::shared_ptr<Netrc>& getNetrc() const
   {
     return netrc_;
   }
diff --git a/src/Notifier.cc b/src/Notifier.cc
index 5228e76f..da43a8cf 100644
--- a/src/Notifier.cc
+++ b/src/Notifier.cc
@@ -43,7 +43,7 @@ Notifier::Notifier() {}
 Notifier::~Notifier() {}
 
 void Notifier::addDownloadEventListener
-(const SharedHandle<DownloadEventListener>& listener)
+(const std::shared_ptr<DownloadEventListener>& listener)
 {
   listeners_.push_back(listener);
 }
@@ -51,7 +51,7 @@ void Notifier::addDownloadEventListener
 void Notifier::notifyDownloadEvent
 (DownloadEvent event, const RequestGroup* group)
 {
-  for(std::vector<SharedHandle<DownloadEventListener> >::const_iterator i =
+  for(std::vector<std::shared_ptr<DownloadEventListener> >::const_iterator i =
         listeners_.begin(), eoi = listeners_.end(); i != eoi; ++i) {
     (*i)->onEvent(event, group);
   }
diff --git a/src/Notifier.h b/src/Notifier.h
index 39787326..e4586c6c 100644
--- a/src/Notifier.h
+++ b/src/Notifier.h
@@ -38,9 +38,9 @@
 #include "common.h"
 
 #include <vector>
+#include <memory>
 
 #include <aria2/aria2.h>
-#include "SharedHandle.h"
 
 namespace aria2 {
 
@@ -56,17 +56,17 @@ public:
   Notifier();
   ~Notifier();
   void addDownloadEventListener
-  (const SharedHandle<DownloadEventListener>& listener);
+  (const std::shared_ptr<DownloadEventListener>& listener);
   // Notifies the download event to all listeners.
   void notifyDownloadEvent(DownloadEvent event, const RequestGroup* group);
 
   void notifyDownloadEvent(DownloadEvent event,
-                           const SharedHandle<RequestGroup>& group)
+                           const std::shared_ptr<RequestGroup>& group)
   {
     notifyDownloadEvent(event, group.get());
   }
 private:
-  std::vector<SharedHandle<DownloadEventListener> > listeners_;
+  std::vector<std::shared_ptr<DownloadEventListener> > listeners_;
 };
 
 } // namespace aria2
diff --git a/src/NullHandle.h b/src/NullHandle.h
index 0e739bda..487a3a3c 100644
--- a/src/NullHandle.h
+++ b/src/NullHandle.h
@@ -35,16 +35,18 @@
 #ifndef D_NULL_HANDLE_H
 #define D_NULL_HANDLE_H
 
-#include "SharedHandle.h"
+#include "common.h"
+
+#include <memory>
 
 namespace aria2 {
 
-// Returns const reference of SharedHandle<T>().  Static variable null
+// Returns const reference of std::shared_ptr<T>().  Static variable null
 // is shared by all instantiation of this function template.
 template<typename T>
-const SharedHandle<T>& getNull()
+const std::shared_ptr<T>& getNull()
 {
-  static SharedHandle<T> null;
+  static std::shared_ptr<T> null;
   return null;
 }
 
diff --git a/src/NullSinkStreamFilter.h b/src/NullSinkStreamFilter.h
index 23d59c86..629ddd75 100644
--- a/src/NullSinkStreamFilter.h
+++ b/src/NullSinkStreamFilter.h
@@ -48,8 +48,8 @@ public:
   virtual void init() {}
 
   virtual ssize_t transform
-  (const SharedHandle<BinaryStream>& out,
-   const SharedHandle<Segment>& segment,
+  (const std::shared_ptr<BinaryStream>& out,
+   const std::shared_ptr<Segment>& segment,
    const unsigned char* inbuf, size_t inlen)
   {
     bytesProcessed_ = inlen;
@@ -75,7 +75,7 @@ public:
     return bytesProcessed_;
   }
 
-  virtual bool installDelegate(const SharedHandle<StreamFilter>& filter)
+  virtual bool installDelegate(const std::shared_ptr<StreamFilter>& filter)
   {
     return false;
   }
diff --git a/src/NullWebSocketSessionMan.h b/src/NullWebSocketSessionMan.h
index 0e5e34d5..acef66d3 100644
--- a/src/NullWebSocketSessionMan.h
+++ b/src/NullWebSocketSessionMan.h
@@ -38,8 +38,7 @@
 #include "common.h"
 
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 // Empty implementation for build without WebSocket support.
 
@@ -55,8 +54,8 @@ class WebSocketSessionMan {
 public:
   WebSocketSessionMan() {}
   ~WebSocketSessionMan() {}
-  void addSession(const SharedHandle<WebSocketSession>& wsSession) {}
-  void removeSession(const SharedHandle<WebSocketSession>& wsSession) {}
+  void addSession(const std::shared_ptr<WebSocketSession>& wsSession) {}
+  void removeSession(const std::shared_ptr<WebSocketSession>& wsSession) {}
   void addNotification(const std::string& method, const RequestGroup* group) {}
 };
 
diff --git a/src/Option.cc b/src/Option.cc
index f86060d7..00ada34a 100644
--- a/src/Option.cc
+++ b/src/Option.cc
@@ -171,12 +171,12 @@ void Option::merge(const Option& option)
   }
 }
 
-void Option::setParent(const SharedHandle<Option>& parent)
+void Option::setParent(const std::shared_ptr<Option>& parent)
 {
   parent_ = parent;
 }
 
-const SharedHandle<Option>& Option::getParent() const
+const std::shared_ptr<Option>& Option::getParent() const
 {
   return parent_;
 }
diff --git a/src/Option.h b/src/Option.h
index c90703e4..ba397c10 100644
--- a/src/Option.h
+++ b/src/Option.h
@@ -39,8 +39,7 @@
 
 #include <string>
 #include <vector>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -50,7 +49,7 @@ class Option {
 private:
   std::vector<std::string> table_;
   std::vector<unsigned char> use_;
-  SharedHandle<Option> parent_;
+  std::shared_ptr<Option> parent_;
 public:
   Option();
   ~Option();
@@ -91,8 +90,8 @@ public:
   // left unmodified for this object.
   void merge(const Option& option);
   // Sets parent Option object for this object.
-  void setParent(const SharedHandle<Option>& parent);
-  const SharedHandle<Option>& getParent() const;
+  void setParent(const std::shared_ptr<Option>& parent);
+  const std::shared_ptr<Option>& getParent() const;
 };
 
 } // namespace aria2
diff --git a/src/OptionHandler.h b/src/OptionHandler.h
index eb9272c2..14f77346 100644
--- a/src/OptionHandler.h
+++ b/src/OptionHandler.h
@@ -42,7 +42,6 @@
 #include <iosfwd>
 #include <functional>
 
-#include "SharedHandle.h"
 #include "console.h"
 
 namespace aria2 {
diff --git a/src/OptionHandlerException.cc b/src/OptionHandlerException.cc
index eb740e5b..6fe1b23c 100644
--- a/src/OptionHandlerException.cc
+++ b/src/OptionHandlerException.cc
@@ -63,9 +63,9 @@ OptionHandlerException::OptionHandlerException
 
 OptionHandlerException::~OptionHandlerException() throw() {}
 
-SharedHandle<Exception> OptionHandlerException::copy() const
+std::shared_ptr<Exception> OptionHandlerException::copy() const
 {
-  SharedHandle<Exception> e(new OptionHandlerException(*this));
+  std::shared_ptr<Exception> e(new OptionHandlerException(*this));
   return e;
 }
 
diff --git a/src/OptionHandlerException.h b/src/OptionHandlerException.h
index 49c456c9..5426ee9d 100644
--- a/src/OptionHandlerException.h
+++ b/src/OptionHandlerException.h
@@ -44,7 +44,7 @@ class OptionHandlerException:public RecoverableException {
 private:
   const Pref* pref_;
 protected:
-  virtual SharedHandle<Exception> copy() const;
+  virtual std::shared_ptr<Exception> copy() const;
 public:
   OptionHandlerException(const char* file, int line,
                          const Pref* pref);
diff --git a/src/OptionHandlerFactory.cc b/src/OptionHandlerFactory.cc
index d0740fd6..9e0e3cec 100644
--- a/src/OptionHandlerFactory.cc
+++ b/src/OptionHandlerFactory.cc
@@ -1351,7 +1351,7 @@ std::vector<OptionHandler*> OptionHandlerFactory::createOptionHandlers()
     OptionHandler* op(new DefaultOptionHandler
                       (PREF_USER_AGENT,
                        TEXT_USER_AGENT,
-                       "aria2/"PACKAGE_VERSION,
+                       "aria2/" PACKAGE_VERSION,
                        A2STR::NIL,
                        OptionHandler::REQ_ARG,
                        'U'));
diff --git a/src/OptionHandlerImpl.cc b/src/OptionHandlerImpl.cc
index 06b4de93..8efc62c8 100644
--- a/src/OptionHandlerImpl.cc
+++ b/src/OptionHandlerImpl.cc
@@ -611,7 +611,7 @@ void PrioritizePieceOptionHandler::parseArg
   // error.
   std::vector<size_t> result;
   util::parsePrioritizePieceRange
-    (result, optarg, std::vector<SharedHandle<FileEntry> >(), 1024);
+    (result, optarg, std::vector<std::shared_ptr<FileEntry> >(), 1024);
   option.put(pref_, optarg);
 }
 
diff --git a/src/OptionParser.cc b/src/OptionParser.cc
index 1cce8495..0cc3ca59 100644
--- a/src/OptionParser.cc
+++ b/src/OptionParser.cc
@@ -38,6 +38,7 @@
 #include <getopt.h>
 
 #include <cstring>
+#include <cassert>
 #include <istream>
 #include <utility>
 
@@ -354,9 +355,9 @@ const OptionHandler* OptionParser::findByShortName(char shortName) const
   return findById(shortOpts_[idx]);
 }
 
-SharedHandle<OptionParser> OptionParser::optionParser_;
+std::shared_ptr<OptionParser> OptionParser::optionParser_;
 
-const SharedHandle<OptionParser>& OptionParser::getInstance()
+const std::shared_ptr<OptionParser>& OptionParser::getInstance()
 {
   if(!optionParser_) {
     optionParser_.reset(new OptionParser());
diff --git a/src/OptionParser.h b/src/OptionParser.h
index 4f7d11a5..02688212 100644
--- a/src/OptionParser.h
+++ b/src/OptionParser.h
@@ -40,9 +40,9 @@
 #include <string>
 #include <vector>
 #include <iosfwd>
+#include <memory>
 
 #include <aria2/aria2.h>
-#include "SharedHandle.h"
 
 namespace aria2 {
 
@@ -55,7 +55,7 @@ private:
   std::vector<OptionHandler*> handlers_;
   // Index of handler in handlers_ for option who has short option name.
   std::vector<size_t> shortOpts_;
-  static SharedHandle<OptionParser> optionParser_;
+  static std::shared_ptr<OptionParser> optionParser_;
 public:
   OptionParser();
   ~OptionParser();
@@ -96,7 +96,7 @@ public:
   // Hidden options are not returned.
   const OptionHandler* findByShortName(char shortName) const;
 
-  static const SharedHandle<OptionParser>& getInstance();
+  static const std::shared_ptr<OptionParser>& getInstance();
   // Deletes statically allocated instace. Call this at the end of the
   // program.
   static void deleteInstance();
diff --git a/src/Peer.h b/src/Peer.h
index ec6a22ec..b0f4a09e 100644
--- a/src/Peer.h
+++ b/src/Peer.h
@@ -42,7 +42,6 @@
 #include <set>
 #include <algorithm>
 
-#include "SharedHandle.h"
 #include "TimerA2.h"
 #include "BtConstants.h"
 #include "PeerStat.h"
diff --git a/src/PeerAbstractCommand.cc b/src/PeerAbstractCommand.cc
index 6ae633d1..df10c9ee 100644
--- a/src/PeerAbstractCommand.cc
+++ b/src/PeerAbstractCommand.cc
@@ -51,9 +51,9 @@ namespace aria2 {
 
 PeerAbstractCommand::PeerAbstractCommand
 (cuid_t cuid,
- const SharedHandle<Peer>& peer,
+ const std::shared_ptr<Peer>& peer,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& s)
+ const std::shared_ptr<SocketCore>& s)
  : Command(cuid),
    checkPoint_(global::wallclock()),
    // TODO referring global option
@@ -136,7 +136,7 @@ void PeerAbstractCommand::disableReadCheckSocket()
   }
 }
 
-void PeerAbstractCommand::setReadCheckSocket(const SharedHandle<SocketCore>& socket)
+void PeerAbstractCommand::setReadCheckSocket(const std::shared_ptr<SocketCore>& socket)
 {
   if(!socket->isOpen()) {
     disableReadCheckSocket();
@@ -164,7 +164,7 @@ void PeerAbstractCommand::disableWriteCheckSocket()
   }
 }
 
-void PeerAbstractCommand::setWriteCheckSocket(const SharedHandle<SocketCore>& socket)
+void PeerAbstractCommand::setWriteCheckSocket(const std::shared_ptr<SocketCore>& socket)
 {
   if(!socket->isOpen()) {
     disableWriteCheckSocket();
diff --git a/src/PeerAbstractCommand.h b/src/PeerAbstractCommand.h
index 50aa719c..147237c1 100644
--- a/src/PeerAbstractCommand.h
+++ b/src/PeerAbstractCommand.h
@@ -36,7 +36,9 @@
 #define D_PEER_ABSTRACT_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "TimerA2.h"
 
 namespace aria2 {
@@ -51,13 +53,13 @@ private:
   Timer checkPoint_;
   time_t timeout_;
   DownloadEngine* e_;
-  SharedHandle<SocketCore> socket_;
-  SharedHandle<Peer> peer_;
+  std::shared_ptr<SocketCore> socket_;
+  std::shared_ptr<Peer> peer_;
 
   bool checkSocketIsReadable_;
   bool checkSocketIsWritable_;
-  SharedHandle<SocketCore> readCheckTarget_;
-  SharedHandle<SocketCore> writeCheckTarget_;
+  std::shared_ptr<SocketCore> readCheckTarget_;
+  std::shared_ptr<SocketCore> writeCheckTarget_;
   bool noCheck_;
 protected:
   DownloadEngine* getDownloadEngine() const
@@ -65,14 +67,14 @@ protected:
     return e_;
   }
 
-  const SharedHandle<SocketCore>& getSocket() const
+  const std::shared_ptr<SocketCore>& getSocket() const
   {
     return socket_;
   }
 
   void createSocket();
 
-  const SharedHandle<Peer>& getPeer() const
+  const std::shared_ptr<Peer>& getPeer() const
   {
     return peer_;
   }
@@ -85,18 +87,18 @@ protected:
   virtual void onFailure(const Exception& err) {};
   virtual bool exitBeforeExecute() = 0;
   virtual bool executeInternal() = 0;
-  void setReadCheckSocket(const SharedHandle<SocketCore>& socket);
-  void setWriteCheckSocket(const SharedHandle<SocketCore>& socket);
+  void setReadCheckSocket(const std::shared_ptr<SocketCore>& socket);
+  void setWriteCheckSocket(const std::shared_ptr<SocketCore>& socket);
   void disableReadCheckSocket();
   void disableWriteCheckSocket();
   void setNoCheck(bool check);
   void updateKeepAlive();
 public:
   PeerAbstractCommand(cuid_t cuid,
-                      const SharedHandle<Peer>& peer,
+                      const std::shared_ptr<Peer>& peer,
                       DownloadEngine* e,
-                      const SharedHandle<SocketCore>& s =
-                      SharedHandle<SocketCore>());
+                      const std::shared_ptr<SocketCore>& s =
+                      std::shared_ptr<SocketCore>());
 
   virtual ~PeerAbstractCommand();
 
diff --git a/src/PeerChokeCommand.cc b/src/PeerChokeCommand.cc
index 035b0636..8568e7d8 100644
--- a/src/PeerChokeCommand.cc
+++ b/src/PeerChokeCommand.cc
@@ -58,13 +58,13 @@ bool PeerChokeCommand::execute() {
 }
 
 void PeerChokeCommand::setBtRuntime
-(const SharedHandle<BtRuntime>& btRuntime)
+(const std::shared_ptr<BtRuntime>& btRuntime)
 {
   btRuntime_ = btRuntime;
 }
 
 void PeerChokeCommand::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
diff --git a/src/PeerChokeCommand.h b/src/PeerChokeCommand.h
index 54feb6eb..8cf5e7a5 100644
--- a/src/PeerChokeCommand.h
+++ b/src/PeerChokeCommand.h
@@ -36,7 +36,8 @@
 #define D_PEER_CHOKE_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -48,9 +49,9 @@ class PeerChokeCommand : public Command {
 private:
   DownloadEngine* e_;
 
-  SharedHandle<PeerStorage> peerStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
 
-  SharedHandle<BtRuntime> btRuntime_;
+  std::shared_ptr<BtRuntime> btRuntime_;
 public:
   PeerChokeCommand(cuid_t cuid,
                    DownloadEngine* e);
@@ -59,9 +60,9 @@ public:
 
   virtual bool execute();
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 
-  void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime);
+  void setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime);
 };
 
 } // namespace aria2
diff --git a/src/PeerConnection.cc b/src/PeerConnection.cc
index d5b6188c..99c19ac6 100644
--- a/src/PeerConnection.cc
+++ b/src/PeerConnection.cc
@@ -64,7 +64,7 @@ enum {
 } // namespace
 
 PeerConnection::PeerConnection
-(cuid_t cuid, const SharedHandle<Peer>& peer, const SharedHandle<SocketCore>& socket)
+(cuid_t cuid, const std::shared_ptr<Peer>& peer, const std::shared_ptr<SocketCore>& socket)
   : cuid_(cuid),
     peer_(peer),
     socket_(socket),
@@ -232,8 +232,8 @@ void PeerConnection::readData
 }
 
 void PeerConnection::enableEncryption
-(const SharedHandle<ARC4Encryptor>& encryptor,
- const SharedHandle<ARC4Encryptor>& decryptor)
+(const std::shared_ptr<ARC4Encryptor>& encryptor,
+ const std::shared_ptr<ARC4Encryptor>& decryptor)
 {
   encryptor_ = encryptor;
   decryptor_ = decryptor;
diff --git a/src/PeerConnection.h b/src/PeerConnection.h
index d3bfec39..09c676ea 100644
--- a/src/PeerConnection.h
+++ b/src/PeerConnection.h
@@ -38,8 +38,8 @@
 #include "common.h"
 
 #include <unistd.h>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "SocketBuffer.h"
 #include "Command.h"
 
@@ -57,8 +57,8 @@ class ARC4Encryptor;
 class PeerConnection {
 private:
   cuid_t cuid_;
-  SharedHandle<Peer> peer_;
-  SharedHandle<SocketCore> socket_;
+  std::shared_ptr<Peer> peer_;
+  std::shared_ptr<SocketCore> socket_;
 
   int msgState_;
   // The capacity of the buffer resbuf_
@@ -77,8 +77,8 @@ private:
   SocketBuffer socketBuffer_;
 
   bool encryptionEnabled_;
-  SharedHandle<ARC4Encryptor> encryptor_;
-  SharedHandle<ARC4Encryptor> decryptor_;
+  std::shared_ptr<ARC4Encryptor> encryptor_;
+  std::shared_ptr<ARC4Encryptor> decryptor_;
 
   bool prevPeek_;
 
@@ -89,8 +89,8 @@ private:
 public:
   PeerConnection
   (cuid_t cuid,
-   const SharedHandle<Peer>& peer,
-   const SharedHandle<SocketCore>& socket);
+   const std::shared_ptr<Peer>& peer,
+   const std::shared_ptr<SocketCore>& socket);
 
   ~PeerConnection();
 
@@ -112,8 +112,8 @@ public:
   bool receiveHandshake
   (unsigned char* data, size_t& dataLength, bool peek = false);
 
-  void enableEncryption(const SharedHandle<ARC4Encryptor>& encryptor,
-                        const SharedHandle<ARC4Encryptor>& decryptor);
+  void enableEncryption(const std::shared_ptr<ARC4Encryptor>& encryptor,
+                        const std::shared_ptr<ARC4Encryptor>& decryptor);
 
   void presetBuffer(const unsigned char* data, size_t length);
 
diff --git a/src/PeerInitiateConnectionCommand.cc b/src/PeerInitiateConnectionCommand.cc
index 5803805b..118163ce 100644
--- a/src/PeerInitiateConnectionCommand.cc
+++ b/src/PeerInitiateConnectionCommand.cc
@@ -56,9 +56,9 @@ namespace aria2 {
 PeerInitiateConnectionCommand::PeerInitiateConnectionCommand
 (cuid_t cuid,
  RequestGroup* requestGroup,
- const SharedHandle<Peer>& peer,
+ const std::shared_ptr<Peer>& peer,
  DownloadEngine* e,
- const SharedHandle<BtRuntime>& btRuntime,
+ const std::shared_ptr<BtRuntime>& btRuntime,
  bool mseHandshakeEnabled)
   : PeerAbstractCommand(cuid, peer, e),
     requestGroup_(requestGroup),
@@ -106,7 +106,7 @@ bool PeerInitiateConnectionCommand::executeInternal() {
 bool PeerInitiateConnectionCommand::prepareForNextPeer(time_t wait) {
   if(peerStorage_->isPeerAvailable() && btRuntime_->lessThanEqMinPeers()) {
     cuid_t ncuid = getDownloadEngine()->newCUID();
-    SharedHandle<Peer> peer = peerStorage_->checkoutPeer(ncuid);
+    std::shared_ptr<Peer> peer = peerStorage_->checkoutPeer(ncuid);
     // sanity check
     if(peer) {
       PeerInitiateConnectionCommand* command;
@@ -131,13 +131,13 @@ bool PeerInitiateConnectionCommand::exitBeforeExecute()
 }
 
 void PeerInitiateConnectionCommand::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
 
 void PeerInitiateConnectionCommand::setPieceStorage
-(const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
diff --git a/src/PeerInitiateConnectionCommand.h b/src/PeerInitiateConnectionCommand.h
index db7262db..50a4f514 100644
--- a/src/PeerInitiateConnectionCommand.h
+++ b/src/PeerInitiateConnectionCommand.h
@@ -48,11 +48,11 @@ class PeerInitiateConnectionCommand : public PeerAbstractCommand {
 private:
   RequestGroup* requestGroup_;
 
-  SharedHandle<BtRuntime> btRuntime_;
+  std::shared_ptr<BtRuntime> btRuntime_;
 
-  SharedHandle<PeerStorage> peerStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
 
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
 
   bool mseHandshakeEnabled_;
 protected:
@@ -64,16 +64,16 @@ protected:
 public:
   PeerInitiateConnectionCommand(cuid_t cuid,
                                 RequestGroup* requestGroup,
-                                const SharedHandle<Peer>& peer,
+                                const std::shared_ptr<Peer>& peer,
                                 DownloadEngine* e,
-                                const SharedHandle<BtRuntime>& btRuntime,
+                                const std::shared_ptr<BtRuntime>& btRuntime,
                                 bool mseHandshakeEnabled = true);
 
   virtual ~PeerInitiateConnectionCommand();
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 };
 
 } // namespace aria2
diff --git a/src/PeerInteractionCommand.cc b/src/PeerInteractionCommand.cc
index f07e42b5..5d762023 100644
--- a/src/PeerInteractionCommand.cc
+++ b/src/PeerInteractionCommand.cc
@@ -82,14 +82,14 @@ namespace aria2 {
 PeerInteractionCommand::PeerInteractionCommand
 (cuid_t cuid,
  RequestGroup* requestGroup,
- const SharedHandle<Peer>& p,
+ const std::shared_ptr<Peer>& p,
  DownloadEngine* e,
- const SharedHandle<BtRuntime>& btRuntime,
- const SharedHandle<PieceStorage>& pieceStorage,
- const SharedHandle<PeerStorage>& peerStorage,
- const SharedHandle<SocketCore>& s,
+ const std::shared_ptr<BtRuntime>& btRuntime,
+ const std::shared_ptr<PieceStorage>& pieceStorage,
+ const std::shared_ptr<PeerStorage>& peerStorage,
+ const std::shared_ptr<SocketCore>& s,
  Seq sequence,
- const SharedHandle<PeerConnection>& passedPeerConnection)
+ const std::shared_ptr<PeerConnection>& passedPeerConnection)
   :PeerAbstractCommand(cuid, p, e, s),
    requestGroup_(requestGroup),
    btRuntime_(btRuntime),
@@ -114,19 +114,19 @@ PeerInteractionCommand::PeerInteractionCommand
     family = AF_INET;
   }
 
-  SharedHandle<TorrentAttribute> torrentAttrs =
+  std::shared_ptr<TorrentAttribute> torrentAttrs =
     bittorrent::getTorrentAttrs(requestGroup_->getDownloadContext());
   bool metadataGetMode = torrentAttrs->metadata.empty();
 
-  SharedHandle<ExtensionMessageRegistry> exMsgRegistry
+  std::shared_ptr<ExtensionMessageRegistry> exMsgRegistry
     (new ExtensionMessageRegistry());
   exMsgRegistry->setExtensionMessageID(ExtensionMessageRegistry::UT_PEX, 8);
   // http://www.bittorrent.org/beps/bep_0009.html
   exMsgRegistry->setExtensionMessageID(ExtensionMessageRegistry::UT_METADATA,
                                        9);
 
-  SharedHandle<UTMetadataRequestFactory> utMetadataRequestFactory;
-  SharedHandle<UTMetadataRequestTracker> utMetadataRequestTracker;
+  std::shared_ptr<UTMetadataRequestFactory> utMetadataRequestFactory;
+  std::shared_ptr<UTMetadataRequestTracker> utMetadataRequestTracker;
   if(metadataGetMode) {
     utMetadataRequestFactory.reset(new UTMetadataRequestFactory());
     utMetadataRequestTracker.reset(new UTMetadataRequestTracker());
@@ -140,7 +140,7 @@ PeerInteractionCommand::PeerInteractionCommand
   extensionMessageFactoryPtr->setUTMetadataRequestTracker
     (utMetadataRequestTracker.get());
   // PieceStorage will be set later.
-  SharedHandle<ExtensionMessageFactory> extensionMessageFactory
+  std::shared_ptr<ExtensionMessageFactory> extensionMessageFactory
     (extensionMessageFactoryPtr);
 
 
@@ -166,10 +166,10 @@ PeerInteractionCommand::PeerInteractionCommand
   if(metadataGetMode) {
     factoryPtr->enableMetadataGetMode();
   }
-  SharedHandle<BtMessageFactory> factory(factoryPtr);
+  std::shared_ptr<BtMessageFactory> factory(factoryPtr);
 
 
-  SharedHandle<PeerConnection> peerConnection;
+  std::shared_ptr<PeerConnection> peerConnection;
   if(!passedPeerConnection) {
     peerConnection.reset(new PeerConnection(cuid, getPeer(), getSocket()));
   } else {
@@ -201,14 +201,14 @@ PeerInteractionCommand::PeerInteractionCommand
   dispatcherPtr->setRequestGroupMan
     (getDownloadEngine()->getRequestGroupMan().get());
   dispatcherPtr->setPeerConnection(peerConnection);
-  SharedHandle<BtMessageDispatcher> dispatcher(dispatcherPtr);
+  std::shared_ptr<BtMessageDispatcher> dispatcher(dispatcherPtr);
 
   DefaultBtMessageReceiver* receiverPtr(new DefaultBtMessageReceiver());
   receiverPtr->setDownloadContext(requestGroup_->getDownloadContext());
   receiverPtr->setPeerConnection(peerConnection.get());
   receiverPtr->setDispatcher(dispatcherPtr);
   receiverPtr->setBtMessageFactory(factoryPtr);
-  SharedHandle<BtMessageReceiver> receiver(receiverPtr);
+  std::shared_ptr<BtMessageReceiver> receiver(receiverPtr);
 
   DefaultBtRequestFactory* reqFactoryPtr(new DefaultBtRequestFactory());
   reqFactoryPtr->setPeer(getPeer());
@@ -216,7 +216,7 @@ PeerInteractionCommand::PeerInteractionCommand
   reqFactoryPtr->setBtMessageDispatcher(dispatcherPtr);
   reqFactoryPtr->setBtMessageFactory(factoryPtr);
   reqFactoryPtr->setCuid(cuid);
-  SharedHandle<BtRequestFactory> reqFactory(reqFactoryPtr);
+  std::shared_ptr<BtRequestFactory> reqFactory(reqFactoryPtr);
 
   DefaultBtInteractive* btInteractivePtr
     (new DefaultBtInteractive(requestGroup_->getDownloadContext(), getPeer()));
@@ -260,7 +260,7 @@ PeerInteractionCommand::PeerInteractionCommand
   if(metadataGetMode) {
     btInteractivePtr->enableMetadataGetMode();
   }
-  SharedHandle<BtInteractive> btInteractive(btInteractivePtr);
+  std::shared_ptr<BtInteractive> btInteractive(btInteractivePtr);
 
   btInteractive_ = btInteractive;
 
@@ -328,7 +328,7 @@ bool PeerInteractionCommand::executeInternal() {
           break;
         }
       }
-      SharedHandle<BtMessage> handshakeMessage =
+      std::shared_ptr<BtMessage> handshakeMessage =
         btInteractive_->receiveHandshake();
       if(!handshakeMessage) {
         done = true;
@@ -339,7 +339,7 @@ bool PeerInteractionCommand::executeInternal() {
       break;
     }
     case RECEIVER_WAIT_HANDSHAKE: {
-      SharedHandle<BtMessage> handshakeMessage =
+      std::shared_ptr<BtMessage> handshakeMessage =
         btInteractive_->receiveAndSendHandshake();
       if(!handshakeMessage) {
         done = true;
@@ -392,7 +392,7 @@ bool PeerInteractionCommand::executeInternal() {
 bool PeerInteractionCommand::prepareForNextPeer(time_t wait) {
   if(peerStorage_->isPeerAvailable() && btRuntime_->lessThanEqMinPeers()) {
     cuid_t ncuid = getDownloadEngine()->newCUID();
-    SharedHandle<Peer> peer = peerStorage_->checkoutPeer(ncuid);
+    std::shared_ptr<Peer> peer = peerStorage_->checkoutPeer(ncuid);
     // sanity check
     if(peer) {
       PeerInitiateConnectionCommand* command;
@@ -424,7 +424,7 @@ bool PeerInteractionCommand::exitBeforeExecute()
   return btRuntime_->isHalt();
 }
 
-const SharedHandle<Option>& PeerInteractionCommand::getOption() const
+const std::shared_ptr<Option>& PeerInteractionCommand::getOption() const
 {
   return requestGroup_->getOption();
 }
diff --git a/src/PeerInteractionCommand.h b/src/PeerInteractionCommand.h
index 9dbdecbd..dae71ddc 100644
--- a/src/PeerInteractionCommand.h
+++ b/src/PeerInteractionCommand.h
@@ -57,16 +57,16 @@ public:
 private:
   RequestGroup* requestGroup_;
 
-  SharedHandle<BtRuntime> btRuntime_;
+  std::shared_ptr<BtRuntime> btRuntime_;
 
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
 
-  SharedHandle<PeerStorage> peerStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
 
   Seq sequence_;
-  SharedHandle<BtInteractive> btInteractive_;
+  std::shared_ptr<BtInteractive> btInteractive_;
 
-  const SharedHandle<Option>& getOption() const;
+  const std::shared_ptr<Option>& getOption() const;
 protected:
   virtual bool executeInternal();
   virtual bool prepareForNextPeer(time_t wait);
@@ -76,15 +76,15 @@ protected:
 public:
   PeerInteractionCommand(cuid_t cuid,
                          RequestGroup* requestGroup,
-                         const SharedHandle<Peer>& peer,
+                         const std::shared_ptr<Peer>& peer,
                          DownloadEngine* e,
-                         const SharedHandle<BtRuntime>& btRuntime,
-                         const SharedHandle<PieceStorage>& pieceStorage,
-                         const SharedHandle<PeerStorage>& peerStorage,
-                         const SharedHandle<SocketCore>& s,
+                         const std::shared_ptr<BtRuntime>& btRuntime,
+                         const std::shared_ptr<PieceStorage>& pieceStorage,
+                         const std::shared_ptr<PeerStorage>& peerStorage,
+                         const std::shared_ptr<SocketCore>& s,
                          Seq sequence,
-                         const SharedHandle<PeerConnection>& peerConnection =
-                         SharedHandle<PeerConnection>());
+                         const std::shared_ptr<PeerConnection>& peerConnection =
+                         std::shared_ptr<PeerConnection>());
 
   virtual ~PeerInteractionCommand();
 };
diff --git a/src/PeerListenCommand.cc b/src/PeerListenCommand.cc
index 75044680..c70a8590 100644
--- a/src/PeerListenCommand.cc
+++ b/src/PeerListenCommand.cc
@@ -107,13 +107,13 @@ bool PeerListenCommand::execute() {
     return true;
   }
   for(int i = 0; i < 3 && socket_->isReadable(0); ++i) {
-    SharedHandle<SocketCore> peerSocket;
+    std::shared_ptr<SocketCore> peerSocket;
     try {
       peerSocket = socket_->acceptConnection();
       std::pair<std::string, uint16_t> peerInfo;
       peerSocket->getPeerInfo(peerInfo);
 
-      SharedHandle<Peer> peer(new Peer(peerInfo.first, peerInfo.second, true));
+      std::shared_ptr<Peer> peer(new Peer(peerInfo.first, peerInfo.second, true));
       cuid_t cuid = e_->newCUID();
       Command* command =
         new ReceiverMSEHandshakeCommand(cuid, peer, e_, peerSocket);
diff --git a/src/PeerListenCommand.h b/src/PeerListenCommand.h
index e061bf54..fa59cfdd 100644
--- a/src/PeerListenCommand.h
+++ b/src/PeerListenCommand.h
@@ -36,7 +36,9 @@
 #define D_PEER_LISTEN_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "SegList.h"
 
 namespace aria2 {
@@ -48,7 +50,7 @@ class PeerListenCommand : public Command {
 private:
   DownloadEngine* e_;
   int family_;
-  SharedHandle<SocketCore> socket_;
+  std::shared_ptr<SocketCore> socket_;
 public:
   PeerListenCommand(cuid_t cuid, DownloadEngine* e, int family);
 
diff --git a/src/PeerReceiveHandshakeCommand.cc b/src/PeerReceiveHandshakeCommand.cc
index b93e049d..5cdd51c3 100644
--- a/src/PeerReceiveHandshakeCommand.cc
+++ b/src/PeerReceiveHandshakeCommand.cc
@@ -63,10 +63,10 @@ namespace aria2 {
 
 PeerReceiveHandshakeCommand::PeerReceiveHandshakeCommand
 (cuid_t cuid,
- const SharedHandle<Peer>& peer,
+ const std::shared_ptr<Peer>& peer,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& s,
- const SharedHandle<PeerConnection>& peerConnection)
+ const std::shared_ptr<SocketCore>& s,
+ const std::shared_ptr<PeerConnection>& peerConnection)
   : PeerAbstractCommand(cuid, peer, e, s),
     peerConnection_(peerConnection)
 {
@@ -102,19 +102,19 @@ bool PeerReceiveHandshakeCommand::executeInternal()
     // check info_hash
     std::string infoHash(&data[28], &data[28+INFO_HASH_LENGTH]);
 
-    SharedHandle<DownloadContext> downloadContext =
+    std::shared_ptr<DownloadContext> downloadContext =
       getDownloadEngine()->getBtRegistry()->getDownloadContext(infoHash);
     if(!downloadContext) {
       throw DL_ABORT_EX
         (fmt("Unknown info hash %s",
              util::toHex(infoHash).c_str()));
     }
-    const SharedHandle<BtObject>& btObject =
+    const std::shared_ptr<BtObject>& btObject =
       getDownloadEngine()->getBtRegistry()->get
       (downloadContext->getOwnerRequestGroup()->getGID());
-    const SharedHandle<BtRuntime>& btRuntime = btObject->btRuntime;
-    const SharedHandle<PieceStorage>& pieceStorage = btObject->pieceStorage;
-    const SharedHandle<PeerStorage>& peerStorage = btObject->peerStorage;
+    const std::shared_ptr<BtRuntime>& btRuntime = btObject->btRuntime;
+    const std::shared_ptr<PieceStorage>& pieceStorage = btObject->pieceStorage;
+    const std::shared_ptr<PeerStorage>& peerStorage = btObject->peerStorage;
     if(!btRuntime->ready()) {
       throw DL_ABORT_EX
         (fmt("Unknown info hash %s",
diff --git a/src/PeerReceiveHandshakeCommand.h b/src/PeerReceiveHandshakeCommand.h
index 4e8a199a..8c0adfff 100644
--- a/src/PeerReceiveHandshakeCommand.h
+++ b/src/PeerReceiveHandshakeCommand.h
@@ -46,18 +46,18 @@ class Peer;
 class PeerReceiveHandshakeCommand:public PeerAbstractCommand
 {
 private:
-  SharedHandle<PeerConnection> peerConnection_;
+  std::shared_ptr<PeerConnection> peerConnection_;
 protected:
   virtual bool executeInternal();
   virtual bool exitBeforeExecute();
 public:
   PeerReceiveHandshakeCommand
   (cuid_t cuid,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    DownloadEngine* e,
-   const SharedHandle<SocketCore>& s,
-   const SharedHandle<PeerConnection>& peerConnection =
-   SharedHandle<PeerConnection>());
+   const std::shared_ptr<SocketCore>& s,
+   const std::shared_ptr<PeerConnection>& peerConnection =
+   std::shared_ptr<PeerConnection>());
 
   virtual ~PeerReceiveHandshakeCommand();
 };
diff --git a/src/PeerStorage.h b/src/PeerStorage.h
index 8db226da..18954d0c 100644
--- a/src/PeerStorage.h
+++ b/src/PeerStorage.h
@@ -40,8 +40,8 @@
 #include <deque>
 #include <vector>
 #include <set>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TransferStat.h"
 #include "Command.h"
 #include "a2functional.h"
@@ -50,7 +50,7 @@ namespace aria2 {
 
 class Peer;
 
-typedef std::set<SharedHandle<Peer>, RefLess<Peer> > PeerSet;
+typedef std::set<std::shared_ptr<Peer>, RefLess<Peer> > PeerSet;
 
 class PeerStorage {
 public:
@@ -60,12 +60,12 @@ public:
    * Adds new peer to the internal peer list.
    * If the peer is added successfully, returns true. Otherwise returns false.
    */
-  virtual bool addPeer(const SharedHandle<Peer>& peer) = 0;
+  virtual bool addPeer(const std::shared_ptr<Peer>& peer) = 0;
 
   /**
    * Adds all peers in peers to internal peer list.
    */
-  virtual void addPeer(const std::vector<SharedHandle<Peer> >& peers) = 0;
+  virtual void addPeer(const std::vector<std::shared_ptr<Peer> >& peers) = 0;
 
   /**
    * Returns the number of peers, including used and unused ones.
@@ -75,7 +75,7 @@ public:
   /**
    * Returns internal dropped peer list.
    */
-  virtual const std::deque<SharedHandle<Peer> >& getDroppedPeers() = 0;
+  virtual const std::deque<std::shared_ptr<Peer> >& getDroppedPeers() = 0;
 
   /**
    * Returns true if at least one unused peer exists.
@@ -102,14 +102,14 @@ public:
   /**
    * Moves first peer in unused peer list to used peer set and calls
    * Peer::usedBy(cuid). If there is no peer available, returns
-   * SharedHandle<Peer>().
+   * std::shared_ptr<Peer>().
    */
-  virtual SharedHandle<Peer> checkoutPeer(cuid_t cuid) = 0;
+  virtual std::shared_ptr<Peer> checkoutPeer(cuid_t cuid) = 0;
 
   /**
    * Tells PeerStorage object that peer is no longer used in the session.
    */
-  virtual void returnPeer(const SharedHandle<Peer>& peer) = 0;
+  virtual void returnPeer(const std::shared_ptr<Peer>& peer) = 0;
 
   virtual bool chokeRoundIntervalElapsed() = 0;
 
diff --git a/src/Piece.cc b/src/Piece.cc
index d2751da7..521788f2 100644
--- a/src/Piece.cc
+++ b/src/Piece.cc
@@ -33,6 +33,9 @@
  */
 /* copyright --> */
 #include "Piece.h"
+
+#include <cassert>
+
 #include "util.h"
 #include "BitfieldMan.h"
 #include "A2STR.h"
@@ -242,8 +245,8 @@ std::string Piece::getDigest()
 }
 
 namespace {
-void updateHashWithRead(const SharedHandle<MessageDigest>& mdctx,
-                        const SharedHandle<DiskAdaptor>& adaptor,
+void updateHashWithRead(const std::shared_ptr<MessageDigest>& mdctx,
+                        const std::shared_ptr<DiskAdaptor>& adaptor,
                         int64_t offset, size_t len)
 {
   const size_t BUFSIZE = 4096;
@@ -269,9 +272,9 @@ void updateHashWithRead(const SharedHandle<MessageDigest>& mdctx,
 } // namespace
 
 std::string Piece::getDigestWithWrCache
-(size_t pieceLength, const SharedHandle<DiskAdaptor>& adaptor)
+(size_t pieceLength, const std::shared_ptr<DiskAdaptor>& adaptor)
 {
-  SharedHandle<MessageDigest> mdctx(MessageDigest::create(hashType_));
+  std::shared_ptr<MessageDigest> mdctx(MessageDigest::create(hashType_));
   int64_t start = static_cast<int64_t>(index_)*pieceLength;
   int64_t goff = start;
   if(wrCache_) {
@@ -317,7 +320,7 @@ void Piece::removeUser(cuid_t cuid)
 }
 
 void Piece::initWrCache(WrDiskCache* diskCache,
-                        const SharedHandle<DiskAdaptor>& diskAdaptor)
+                        const std::shared_ptr<DiskAdaptor>& diskAdaptor)
 {
   if(!diskCache) {
     return;
diff --git a/src/Piece.h b/src/Piece.h
index ca3573ee..bdba7dd2 100644
--- a/src/Piece.h
+++ b/src/Piece.h
@@ -40,8 +40,8 @@
 #include <stdint.h>
 #include <vector>
 #include <string>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "Command.h"
 
 namespace aria2 {
@@ -72,7 +72,7 @@ private:
 
   std::string hashType_;
 
-  SharedHandle<MessageDigest> mdctx_;
+  std::shared_ptr<MessageDigest> mdctx_;
 
 #endif // ENABLE_MESSAGE_DIGEST
 
@@ -179,7 +179,7 @@ public:
   // Returns raw hash value, not hex digest, which is calculated using
   // cached data and data on disk.
   std::string getDigestWithWrCache(size_t pieceLength,
-                                   const SharedHandle<DiskAdaptor>& adaptor);
+                                   const std::shared_ptr<DiskAdaptor>& adaptor);
 #endif // ENABLE_MESSAGE_DIGEST
 
   /**
@@ -204,7 +204,7 @@ public:
   }
 
   void initWrCache(WrDiskCache* diskCache,
-                   const SharedHandle<DiskAdaptor>& diskAdaptor);
+                   const std::shared_ptr<DiskAdaptor>& diskAdaptor);
   void flushWrCache(WrDiskCache* diskCache);
   void clearWrCache(WrDiskCache* diskCache);
   void updateWrCache(WrDiskCache* diskCache, unsigned char* data,
diff --git a/src/PieceHashCheckIntegrityEntry.cc b/src/PieceHashCheckIntegrityEntry.cc
index 7af39539..f4e12010 100644
--- a/src/PieceHashCheckIntegrityEntry.cc
+++ b/src/PieceHashCheckIntegrityEntry.cc
@@ -49,7 +49,7 @@ PieceHashCheckIntegrityEntry::~PieceHashCheckIntegrityEntry() {}
 
 bool PieceHashCheckIntegrityEntry::isValidationReady()
 {
-  const SharedHandle<DownloadContext>& dctx =
+  const std::shared_ptr<DownloadContext>& dctx =
     getRequestGroup()->getDownloadContext();
   return dctx->isPieceHashVerificationAvailable();
 }
@@ -57,7 +57,7 @@ bool PieceHashCheckIntegrityEntry::isValidationReady()
 void PieceHashCheckIntegrityEntry::initValidator()
 {
 #ifdef ENABLE_MESSAGE_DIGEST
-  SharedHandle<IteratableChunkChecksumValidator> validator
+  std::shared_ptr<IteratableChunkChecksumValidator> validator
     (new IteratableChunkChecksumValidator
      (getRequestGroup()->getDownloadContext(),
       getRequestGroup()->getPieceStorage()));
diff --git a/src/PieceStatMan.h b/src/PieceStatMan.h
index 96ea824b..dd70c125 100644
--- a/src/PieceStatMan.h
+++ b/src/PieceStatMan.h
@@ -39,8 +39,6 @@
 
 #include <vector>
 
-#include "SharedHandle.h"
-
 namespace aria2 {
 
 class PieceStatMan {
diff --git a/src/PieceStorage.h b/src/PieceStorage.h
index 14b7160a..06bccb50 100644
--- a/src/PieceStorage.h
+++ b/src/PieceStorage.h
@@ -39,8 +39,8 @@
 
 #include <string>
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimerA2.h"
 #include "Command.h"
 
@@ -62,7 +62,7 @@ public:
    * Returns true if the peer has a piece that localhost doesn't have.
    * Otherwise returns false.
    */
-  virtual bool hasMissingPiece(const SharedHandle<Peer>& peer) = 0;
+  virtual bool hasMissingPiece(const std::shared_ptr<Peer>& peer) = 0;
 
    // Stores pieces that the peer has but localhost doesn't.  Those
    // pieces will be marked "used" status in order to prevent other
@@ -73,17 +73,17 @@ public:
    // pieces is greater than or equal to minMissingBlocks. If there is
    // M missing pieces left where M < N, M pieces are stored.
   virtual void getMissingPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    cuid_t cuid) = 0;
 
   // Same as getMissingPiece(pieces, minMissingBlocks, peer), but the
   // indexes in excludedIndexes are excluded.
   virtual void getMissingPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
    cuid_t cuid) = 0;
 
@@ -97,17 +97,17 @@ public:
   // greater than or equal to minMissingBlocks. If there is M missing
   // pieces left where M < N, M pieces are stored.
   virtual void getMissingFastPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    cuid_t cuid) = 0;
 
   // Same as getMissingFastPiece(pieces, minMissingBlocks, peer), but
   // the indexes in excludedIndexes are excluded.
   virtual void getMissingFastPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
    cuid_t cuid) = 0;
 
@@ -117,15 +117,15 @@ public:
    * from get the same piece. But in end game mode, same piece may be returned
    * to several commands.
    */
-  virtual SharedHandle<Piece>
-  getMissingPiece(const SharedHandle<Peer>& peer, cuid_t cuid) = 0;
+  virtual std::shared_ptr<Piece>
+  getMissingPiece(const std::shared_ptr<Peer>& peer, cuid_t cuid) = 0;
 
   /**
-   * Same as getMissingPiece(const SharedHandle<Peer>& peer), but the indexes in
+   * Same as getMissingPiece(const std::shared_ptr<Peer>& peer), but the indexes in
    * excludedIndexes are excluded.
    */
-  virtual SharedHandle<Piece> getMissingPiece
-  (const SharedHandle<Peer>& peer,
+  virtual std::shared_ptr<Piece> getMissingPiece
+  (const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
    cuid_t cuid) = 0;
 #endif // ENABLE_BITTORRENT
@@ -137,7 +137,7 @@ public:
    * Returns a missing piece if available. Otherwise returns 0;
    * If ignoreBitfield is set, indexes of true bit are excluded.
    */
-  virtual SharedHandle<Piece> getMissingPiece
+  virtual std::shared_ptr<Piece> getMissingPiece
   (size_t minSplitSize,
    const unsigned char* ignoreBitfield,
    size_t length,
@@ -149,13 +149,13 @@ public:
    * then returns 0.
    * Also returns 0 if any of missing piece is not available.
    */
-  virtual SharedHandle<Piece> getMissingPiece(size_t index, cuid_t cuid) = 0;
+  virtual std::shared_ptr<Piece> getMissingPiece(size_t index, cuid_t cuid) = 0;
 
   /**
    * Returns the piece denoted by index.
    * No status of the piece is changed in this method.
    */
-  virtual SharedHandle<Piece> getPiece(size_t index) = 0;
+  virtual std::shared_ptr<Piece> getPiece(size_t index) = 0;
 
   /**
    * Marks the piece whose index is index as missing.
@@ -165,12 +165,12 @@ public:
   /**
    * Tells that the download of the specfied piece completes.
    */
-  virtual void completePiece(const SharedHandle<Piece>& piece) = 0;
+  virtual void completePiece(const std::shared_ptr<Piece>& piece) = 0;
 
   /**
    * Tells that the download of the specified piece is canceled.
    */
-  virtual void cancelPiece(const SharedHandle<Piece>& piece, cuid_t cuid) = 0;
+  virtual void cancelPiece(const std::shared_ptr<Piece>& piece, cuid_t cuid) = 0;
 
   /**
    * Returns true if the specified piece is already downloaded.
@@ -227,7 +227,7 @@ public:
   // TODO We can remove this.
   virtual void setEndGamePieceNum(size_t num) = 0;
 
-  virtual SharedHandle<DiskAdaptor> getDiskAdaptor() = 0;
+  virtual std::shared_ptr<DiskAdaptor> getDiskAdaptor() = 0;
 
   virtual WrDiskCache* getWrDiskCache() = 0;
 
@@ -267,11 +267,11 @@ public:
   virtual void markPiecesDone(int64_t length) = 0;
 
   virtual void
-  addInFlightPiece(const std::vector<SharedHandle<Piece> >& pieces) = 0;
+  addInFlightPiece(const std::vector<std::shared_ptr<Piece> >& pieces) = 0;
 
   virtual size_t countInFlightPiece() = 0;
 
-  virtual void getInFlightPieces(std::vector<SharedHandle<Piece> >& pieces) = 0;
+  virtual void getInFlightPieces(std::vector<std::shared_ptr<Piece> >& pieces) = 0;
 
   virtual void addPieceStats(size_t index) = 0;
 
diff --git a/src/PiecedSegment.cc b/src/PiecedSegment.cc
index ab100d9a..e1ebcdde 100644
--- a/src/PiecedSegment.cc
+++ b/src/PiecedSegment.cc
@@ -39,7 +39,7 @@
 namespace aria2 {
 
 PiecedSegment::PiecedSegment
-(int32_t pieceLength, const SharedHandle<Piece>& piece)
+(int32_t pieceLength, const std::shared_ptr<Piece>& piece)
   : piece_(piece),
     pieceLength_(pieceLength)
 {
@@ -124,7 +124,7 @@ void PiecedSegment::clear(WrDiskCache* diskCache)
 #endif // ENABLE_MESSAGE_DIGEST
 }
 
-SharedHandle<Piece> PiecedSegment::getPiece() const
+std::shared_ptr<Piece> PiecedSegment::getPiece() const
 {
   return piece_;
 }
diff --git a/src/PiecedSegment.h b/src/PiecedSegment.h
index 94d423d4..4e7fda31 100644
--- a/src/PiecedSegment.h
+++ b/src/PiecedSegment.h
@@ -41,7 +41,7 @@ namespace aria2 {
 
 class PiecedSegment:public Segment {
 private:
-  SharedHandle<Piece> piece_;
+  std::shared_ptr<Piece> piece_;
   /**
    * Piece class has length property but it is a actual length of piece.
    * The last piece likely have shorter length than the other length.
@@ -50,7 +50,7 @@ private:
   int32_t writtenLength_;
 
 public:
-  PiecedSegment(int32_t pieceLength, const SharedHandle<Piece>& piece);
+  PiecedSegment(int32_t pieceLength, const std::shared_ptr<Piece>& piece);
 
   virtual ~PiecedSegment();
 
@@ -92,7 +92,7 @@ public:
 
   virtual void clear(WrDiskCache* diskCache);
 
-  virtual SharedHandle<Piece> getPiece() const;
+  virtual std::shared_ptr<Piece> getPiece() const;
 };
 
 } // namespace aria2
diff --git a/src/PollEventPoll.cc b/src/PollEventPoll.cc
index ba4f479b..eee58e4c 100644
--- a/src/PollEventPoll.cc
+++ b/src/PollEventPoll.cc
@@ -96,7 +96,7 @@ void PollEventPoll::poll(const struct timeval& tv)
   while((res = ::poll(pollfds_, pollfdNum_, timeout)) == -1 &&
         errno == EINTR);
   if(res > 0) {
-    SharedHandle<KSocketEntry> se(new KSocketEntry(0));
+    std::shared_ptr<KSocketEntry> se(new KSocketEntry(0));
     for(struct pollfd* first = pollfds_, *last = pollfds_+pollfdNum_;
         first != last; ++first) {
       if(first->revents) {
@@ -152,7 +152,7 @@ int PollEventPoll::translateEvents(EventPoll::EventType events)
 bool PollEventPoll::addEvents
 (sock_t socket, const PollEventPoll::KEvent& event)
 {
-  SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
+  std::shared_ptr<KSocketEntry> socketEntry(new KSocketEntry(socket));
   KSocketEntrySet::iterator i = socketEntries_.lower_bound(socketEntry);
   if(i != socketEntries_.end() && *(*i) == *socketEntry) {
     event.addSelf(*i);
@@ -189,7 +189,7 @@ bool PollEventPoll::addEvents
 #ifdef ENABLE_ASYNC_DNS
 bool PollEventPoll::addEvents
 (sock_t socket, Command* command, int events,
- const SharedHandle<AsyncNameResolver>& rs)
+ const std::shared_ptr<AsyncNameResolver>& rs)
 {
   return addEvents(socket, KADNSEvent(rs, command, socket, events));
 }
@@ -198,7 +198,7 @@ bool PollEventPoll::addEvents
 bool PollEventPoll::deleteEvents
 (sock_t socket, const PollEventPoll::KEvent& event)
 {
-  SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
+  std::shared_ptr<KSocketEntry> socketEntry(new KSocketEntry(socket));
   KSocketEntrySet::iterator i = socketEntries_.find(socketEntry);
   if(i == socketEntries_.end()) {
     A2_LOG_DEBUG(fmt("Socket %d is not found in SocketEntries.", socket));
@@ -226,7 +226,7 @@ bool PollEventPoll::deleteEvents
 
 #ifdef ENABLE_ASYNC_DNS
 bool PollEventPoll::deleteEvents
-(sock_t socket, Command* command, const SharedHandle<AsyncNameResolver>& rs)
+(sock_t socket, Command* command, const std::shared_ptr<AsyncNameResolver>& rs)
 {
   return deleteEvents(socket, KADNSEvent(rs, command, socket, 0));
 }
@@ -241,9 +241,9 @@ bool PollEventPoll::deleteEvents
 
 #ifdef ENABLE_ASYNC_DNS
 bool PollEventPoll::addNameResolver
-(const SharedHandle<AsyncNameResolver>& resolver, Command* command)
+(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
-  SharedHandle<KAsyncNameResolverEntry> entry
+  std::shared_ptr<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   KAsyncNameResolverEntrySet::iterator itr =
     nameResolverEntries_.lower_bound(entry);
@@ -257,9 +257,9 @@ bool PollEventPoll::addNameResolver
 }
 
 bool PollEventPoll::deleteNameResolver
-(const SharedHandle<AsyncNameResolver>& resolver, Command* command)
+(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
-  SharedHandle<KAsyncNameResolverEntry> entry
+  std::shared_ptr<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   KAsyncNameResolverEntrySet::iterator itr = nameResolverEntries_.find(entry);
   if(itr == nameResolverEntries_.end()) {
diff --git a/src/PollEventPoll.h b/src/PollEventPoll.h
index af4de886..730a7da6 100644
--- a/src/PollEventPoll.h
+++ b/src/PollEventPoll.h
@@ -70,12 +70,12 @@ private:
   friend int accumulateEvent(int events, const KEvent& event);
 
 private:
-  typedef std::set<SharedHandle<KSocketEntry>,
-                   DerefLess<SharedHandle<KSocketEntry> > > KSocketEntrySet;
+  typedef std::set<std::shared_ptr<KSocketEntry>,
+                   DerefLess<std::shared_ptr<KSocketEntry> > > KSocketEntrySet;
   KSocketEntrySet socketEntries_;
 #ifdef ENABLE_ASYNC_DNS
-  typedef std::set<SharedHandle<KAsyncNameResolverEntry>,
-                   DerefLess<SharedHandle<KAsyncNameResolverEntry> > >
+  typedef std::set<std::shared_ptr<KAsyncNameResolverEntry>,
+                   DerefLess<std::shared_ptr<KAsyncNameResolverEntry> > >
   KAsyncNameResolverEntrySet;
   KAsyncNameResolverEntrySet nameResolverEntries_;
 #endif // ENABLE_ASYNC_DNS
@@ -93,10 +93,10 @@ private:
   bool deleteEvents(sock_t socket, const KEvent& event);
 
   bool addEvents(sock_t socket, Command* command, int events,
-                 const SharedHandle<AsyncNameResolver>& rs);
+                 const std::shared_ptr<AsyncNameResolver>& rs);
 
   bool deleteEvents(sock_t socket, Command* command,
-                    const SharedHandle<AsyncNameResolver>& rs);
+                    const std::shared_ptr<AsyncNameResolver>& rs);
 
   static int translateEvents(EventPoll::EventType events);
 public:
@@ -113,10 +113,10 @@ public:
                             Command* command, EventPoll::EventType events);
 #ifdef ENABLE_ASYNC_DNS
 
-  virtual bool addNameResolver(const SharedHandle<AsyncNameResolver>& resolver,
+  virtual bool addNameResolver(const std::shared_ptr<AsyncNameResolver>& resolver,
                                Command* command);
   virtual bool deleteNameResolver
-  (const SharedHandle<AsyncNameResolver>& resolver, Command* command);
+  (const std::shared_ptr<AsyncNameResolver>& resolver, Command* command);
 #endif // ENABLE_ASYNC_DNS
 
   static const int IEV_READ = POLLIN;
diff --git a/src/PortEventPoll.cc b/src/PortEventPoll.cc
index 577fe074..0610cd97 100644
--- a/src/PortEventPoll.cc
+++ b/src/PortEventPoll.cc
@@ -174,7 +174,7 @@ int translateEvents(EventPoll::EventType events)
 bool PortEventPoll::addEvents(sock_t socket,
                               const PortEventPoll::KEvent& event)
 {
-  SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
+  std::shared_ptr<KSocketEntry> socketEntry(new KSocketEntry(socket));
   KSocketEntrySet::iterator i = socketEntries_.lower_bound(socketEntry);
   int r = 0;
   int errNum = 0;
@@ -215,7 +215,7 @@ bool PortEventPoll::addEvents(sock_t socket, Command* command,
 
 #ifdef ENABLE_ASYNC_DNS
 bool PortEventPoll::addEvents(sock_t socket, Command* command, int events,
-                              const SharedHandle<AsyncNameResolver>& rs)
+                              const std::shared_ptr<AsyncNameResolver>& rs)
 {
   return addEvents(socket, KADNSEvent(rs, command, socket, events));
 }
@@ -224,7 +224,7 @@ bool PortEventPoll::addEvents(sock_t socket, Command* command, int events,
 bool PortEventPoll::deleteEvents(sock_t socket,
                                  const PortEventPoll::KEvent& event)
 {
-  SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
+  std::shared_ptr<KSocketEntry> socketEntry(new KSocketEntry(socket));
   KSocketEntrySet::iterator i = socketEntries_.find(socketEntry);
   if(i == socketEntries_.end()) {
     A2_LOG_DEBUG(fmt("Socket %d is not found in SocketEntries.", socket));
@@ -255,7 +255,7 @@ bool PortEventPoll::deleteEvents(sock_t socket,
 
 #ifdef ENABLE_ASYNC_DNS
 bool PortEventPoll::deleteEvents(sock_t socket, Command* command,
-                                 const SharedHandle<AsyncNameResolver>& rs)
+                                 const std::shared_ptr<AsyncNameResolver>& rs)
 {
   return deleteEvents(socket, KADNSEvent(rs, command, socket, 0));
 }
@@ -270,9 +270,9 @@ bool PortEventPoll::deleteEvents(sock_t socket, Command* command,
 
 #ifdef ENABLE_ASYNC_DNS
 bool PortEventPoll::addNameResolver
-(const SharedHandle<AsyncNameResolver>& resolver, Command* command)
+(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
-  SharedHandle<KAsyncNameResolverEntry> entry
+  std::shared_ptr<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   KAsyncNameResolverEntrySet::iterator itr = nameResolverEntries_.find(entry);
   if(itr == nameResolverEntries_.end()) {
@@ -285,9 +285,9 @@ bool PortEventPoll::addNameResolver
 }
 
 bool PortEventPoll::deleteNameResolver
-(const SharedHandle<AsyncNameResolver>& resolver, Command* command)
+(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
-  SharedHandle<KAsyncNameResolverEntry> entry
+  std::shared_ptr<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   KAsyncNameResolverEntrySet::iterator itr = nameResolverEntries_.find(entry);
   if(itr == nameResolverEntries_.end()) {
diff --git a/src/PortEventPoll.h b/src/PortEventPoll.h
index ad4a4364..3f25e3dd 100644
--- a/src/PortEventPoll.h
+++ b/src/PortEventPoll.h
@@ -77,12 +77,12 @@ private:
   friend int accumulateEvent(int events, const KEvent& event);
 
 private:
-  typedef std::set<SharedHandle<KSocketEntry>,
-                   DerefLess<SharedHandle<KSocketEntry> > > KSocketEntrySet;
+  typedef std::set<std::shared_ptr<KSocketEntry>,
+                   DerefLess<std::shared_ptr<KSocketEntry> > > KSocketEntrySet;
   KSocketEntrySet socketEntries_;
 #ifdef ENABLE_ASYNC_DNS
-  typedef std::set<SharedHandle<KAsyncNameResolverEntry>,
-                   DerefLess<SharedHandle<KAsyncNameResolverEntry> > >
+  typedef std::set<std::shared_ptr<KAsyncNameResolverEntry>,
+                   DerefLess<std::shared_ptr<KAsyncNameResolverEntry> > >
   KAsyncNameResolverEntrySet;
   KAsyncNameResolverEntrySet nameResolverEntries_;
 #endif // ENABLE_ASYNC_DNS
@@ -100,10 +100,10 @@ private:
   bool deleteEvents(sock_t socket, const KEvent& event);
 
   bool addEvents(sock_t socket, Command* command, int events,
-                 const SharedHandle<AsyncNameResolver>& rs);
+                 const std::shared_ptr<AsyncNameResolver>& rs);
 
   bool deleteEvents(sock_t socket, Command* command,
-                    const SharedHandle<AsyncNameResolver>& rs);
+                    const std::shared_ptr<AsyncNameResolver>& rs);
 
 public:
   PortEventPoll();
@@ -121,10 +121,10 @@ public:
                             Command* command, EventPoll::EventType events);
 #ifdef ENABLE_ASYNC_DNS
 
-  virtual bool addNameResolver(const SharedHandle<AsyncNameResolver>& resolver,
+  virtual bool addNameResolver(const std::shared_ptr<AsyncNameResolver>& resolver,
                                Command* command);
   virtual bool deleteNameResolver
-  (const SharedHandle<AsyncNameResolver>& resolver, Command* command);
+  (const std::shared_ptr<AsyncNameResolver>& resolver, Command* command);
 #endif // ENABLE_ASYNC_DNS
 
   static const int IEV_READ = POLLIN;
diff --git a/src/PostDownloadHandler.h b/src/PostDownloadHandler.h
index e89b14d1..fe21dbfc 100644
--- a/src/PostDownloadHandler.h
+++ b/src/PostDownloadHandler.h
@@ -49,7 +49,7 @@ public:
   virtual ~PostDownloadHandler() {}
 
   virtual void
-  getNextRequestGroups(std::vector<SharedHandle<RequestGroup> >& groups,
+  getNextRequestGroups(std::vector<std::shared_ptr<RequestGroup> >& groups,
                        RequestGroup* requestGroup) = 0;
 };
 
diff --git a/src/PriorityPieceSelector.cc b/src/PriorityPieceSelector.cc
index eb03ed56..98ff96b7 100644
--- a/src/PriorityPieceSelector.cc
+++ b/src/PriorityPieceSelector.cc
@@ -38,7 +38,7 @@
 namespace aria2 {
 
 PriorityPieceSelector::PriorityPieceSelector
-(const SharedHandle<PieceSelector>& selector):
+(const std::shared_ptr<PieceSelector>& selector):
   selector_(selector) {}
 
 bool PriorityPieceSelector::select
diff --git a/src/PriorityPieceSelector.h b/src/PriorityPieceSelector.h
index 5401747d..8360af56 100644
--- a/src/PriorityPieceSelector.h
+++ b/src/PriorityPieceSelector.h
@@ -38,8 +38,7 @@
 #include "PieceSelector.h"
 
 #include <vector>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -47,9 +46,9 @@ class PriorityPieceSelector:public PieceSelector {
 private:
   std::vector<size_t> prioritizedPieces_;
 
-  SharedHandle<PieceSelector> selector_;
+  std::shared_ptr<PieceSelector> selector_;
 public:
-  PriorityPieceSelector(const SharedHandle<PieceSelector>& selector);
+  PriorityPieceSelector(const std::shared_ptr<PieceSelector>& selector);
 
   virtual bool select
   (size_t& index, const unsigned char* bitfield, size_t nbits) const;
diff --git a/src/RarestPieceSelector.cc b/src/RarestPieceSelector.cc
index 3cc78077..a561c34f 100644
--- a/src/RarestPieceSelector.cc
+++ b/src/RarestPieceSelector.cc
@@ -43,7 +43,7 @@
 namespace aria2 {
 
 RarestPieceSelector::RarestPieceSelector
-(const SharedHandle<PieceStatMan>& pieceStatMan):pieceStatMan_(pieceStatMan) {}
+(const std::shared_ptr<PieceStatMan>& pieceStatMan):pieceStatMan_(pieceStatMan) {}
 
 bool RarestPieceSelector::select
 (size_t& index, const unsigned char* bitfield, size_t nbits) const
diff --git a/src/RarestPieceSelector.h b/src/RarestPieceSelector.h
index 4496e602..91abe956 100644
--- a/src/RarestPieceSelector.h
+++ b/src/RarestPieceSelector.h
@@ -36,7 +36,8 @@
 #define D_RAREST_PIECE_SELECTOR_H
 
 #include "PieceSelector.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -44,9 +45,9 @@ class PieceStatMan;
 
 class RarestPieceSelector:public PieceSelector {
 private:
-  SharedHandle<PieceStatMan> pieceStatMan_;
+  std::shared_ptr<PieceStatMan> pieceStatMan_;
 public:
-  RarestPieceSelector(const SharedHandle<PieceStatMan>& pieceStatMan);
+  RarestPieceSelector(const std::shared_ptr<PieceStatMan>& pieceStatMan);
 
   virtual bool select
   (size_t& index, const unsigned char* bitfield, size_t nbits) const;
diff --git a/src/ReceiverMSEHandshakeCommand.cc b/src/ReceiverMSEHandshakeCommand.cc
index e64e591e..c458a924 100644
--- a/src/ReceiverMSEHandshakeCommand.cc
+++ b/src/ReceiverMSEHandshakeCommand.cc
@@ -55,9 +55,9 @@ namespace aria2 {
 
 ReceiverMSEHandshakeCommand::ReceiverMSEHandshakeCommand
 (cuid_t cuid,
- const SharedHandle<Peer>& peer,
+ const std::shared_ptr<Peer>& peer,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& s):
+ const std::shared_ptr<SocketCore>& s):
 
   PeerAbstractCommand(cuid, peer, e, s),
   sequence_(RECEIVER_IDENTIFY_HANDSHAKE),
@@ -103,7 +103,7 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
             ("The legacy BitTorrent handshake is not acceptable by the"
              " preference.");
         }
-        SharedHandle<PeerConnection> peerConnection
+        std::shared_ptr<PeerConnection> peerConnection
           (new PeerConnection(getCuid(), getPeer(), getSocket()));
         peerConnection->presetBuffer(mseHandshake_->getBuffer(),
                                      mseHandshake_->getBufferLength());
@@ -145,7 +145,7 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
       break;
     }
     case RECEIVER_RECEIVE_PAD_C_LENGTH: {
-      std::vector<SharedHandle<DownloadContext> > downloadContexts;
+      std::vector<std::shared_ptr<DownloadContext> > downloadContexts;
       getDownloadEngine()->getBtRegistry()->getAllDownloadContext
         (std::back_inserter(downloadContexts));
       if(mseHandshake_->receiveReceiverHashAndPadCLength(downloadContexts)) {
@@ -206,7 +206,7 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
 
 void ReceiverMSEHandshakeCommand::createCommand()
 {
-  SharedHandle<PeerConnection> peerConnection
+  std::shared_ptr<PeerConnection> peerConnection
     (new PeerConnection(getCuid(), getPeer(), getSocket()));
   if(mseHandshake_->getNegotiatedCryptoType() == MSEHandshake::CRYPTO_ARC4) {
     peerConnection->enableEncryption(mseHandshake_->getEncryptor(),
diff --git a/src/ReceiverMSEHandshakeCommand.h b/src/ReceiverMSEHandshakeCommand.h
index eb76acc0..a5feea30 100644
--- a/src/ReceiverMSEHandshakeCommand.h
+++ b/src/ReceiverMSEHandshakeCommand.h
@@ -68,9 +68,9 @@ protected:
   virtual bool exitBeforeExecute();
 public:
   ReceiverMSEHandshakeCommand(cuid_t cuid,
-                              const SharedHandle<Peer>& peer,
+                              const std::shared_ptr<Peer>& peer,
                               DownloadEngine* e,
-                              const SharedHandle<SocketCore>& s);
+                              const std::shared_ptr<SocketCore>& s);
 
   virtual ~ReceiverMSEHandshakeCommand();
 };
diff --git a/src/RecoverableException.cc b/src/RecoverableException.cc
index 546c86eb..75f73b81 100644
--- a/src/RecoverableException.cc
+++ b/src/RecoverableException.cc
@@ -36,9 +36,9 @@
 
 namespace aria2 {
 
-SharedHandle<Exception> RecoverableException::copy() const
+std::shared_ptr<Exception> RecoverableException::copy() const
 {
-  SharedHandle<Exception> e(new RecoverableException(*this));
+  std::shared_ptr<Exception> e(new RecoverableException(*this));
   return e;
 }
 
diff --git a/src/RecoverableException.h b/src/RecoverableException.h
index 87a6b07e..e5a98d81 100644
--- a/src/RecoverableException.h
+++ b/src/RecoverableException.h
@@ -40,7 +40,7 @@ namespace aria2 {
 
 class RecoverableException:public Exception {
 protected:
-  virtual SharedHandle<Exception> copy() const;
+  virtual std::shared_ptr<Exception> copy() const;
 public:
   RecoverableException(const char* file, int line, const std::string& msg);
 
diff --git a/src/Request.cc b/src/Request.cc
index 6a58c304..ad7b934f 100644
--- a/src/Request.cc
+++ b/src/Request.cc
@@ -158,7 +158,7 @@ void Request::setMaxPipelinedRequest(int num)
   maxPipelinedRequest_ = num;
 }
 
-const SharedHandle<PeerStat>& Request::initPeerStat()
+const std::shared_ptr<PeerStat>& Request::initPeerStat()
 {
   // Use host and protocol in original URI, because URI selector
   // selects URI based on original URI, not redirected one.
diff --git a/src/Request.h b/src/Request.h
index ebdad6b3..24850584 100644
--- a/src/Request.h
+++ b/src/Request.h
@@ -37,8 +37,8 @@
 #include "common.h"
 
 #include <string>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimerA2.h"
 #include "uri.h"
 
@@ -73,7 +73,7 @@ private:
   bool pipeliningHint_;
   // maximum number of pipelined requests
   int maxPipelinedRequest_;
-  SharedHandle<PeerStat> peerStat_;
+  std::shared_ptr<PeerStat> peerStat_;
   bool removalRequested_;
   uint16_t connectedPort_;
   Timer wakeTime_;
@@ -176,12 +176,12 @@ public:
     return method_;
   }
 
-  const SharedHandle<PeerStat>& getPeerStat() const
+  const std::shared_ptr<PeerStat>& getPeerStat() const
   {
     return peerStat_;
   }
 
-  const SharedHandle<PeerStat>& initPeerStat();
+  const std::shared_ptr<PeerStat>& initPeerStat();
 
   void requestRemoval()
   {
diff --git a/src/RequestGroup.cc b/src/RequestGroup.cc
index 1491981d..d62c8431 100644
--- a/src/RequestGroup.cc
+++ b/src/RequestGroup.cc
@@ -120,8 +120,8 @@
 
 namespace aria2 {
 
-RequestGroup::RequestGroup(const SharedHandle<GroupId>& gid,
-                           const SharedHandle<Option>& option)
+RequestGroup::RequestGroup(const std::shared_ptr<GroupId>& gid,
+                           const std::shared_ptr<Option>& option)
   : gid_(gid),
     state_(STATE_WAITING),
     option_(option),
@@ -216,12 +216,12 @@ void RequestGroup::closeFile()
 
 // TODO The function name is not intuitive at all.. it does not convey
 // that this function open file.
-SharedHandle<CheckIntegrityEntry> RequestGroup::createCheckIntegrityEntry()
+std::shared_ptr<CheckIntegrityEntry> RequestGroup::createCheckIntegrityEntry()
 {
-  SharedHandle<BtProgressInfoFile> infoFile
+  std::shared_ptr<BtProgressInfoFile> infoFile
     (new DefaultBtProgressInfoFile(downloadContext_, pieceStorage_,
                                    option_.get()));
-  SharedHandle<CheckIntegrityEntry> checkEntry;
+  std::shared_ptr<CheckIntegrityEntry> checkEntry;
   if(option_->getAsBool(PREF_CHECK_INTEGRITY) &&
      downloadContext_->isPieceHashVerificationAvailable()) {
     // When checking piece hash, we don't care file is downloaded and
@@ -287,14 +287,14 @@ void RequestGroup::createInitialCommand
 #ifdef ENABLE_BITTORRENT
   {
     if(downloadContext_->hasAttribute(CTX_ATTR_BT)) {
-      SharedHandle<TorrentAttribute> torrentAttrs =
+      std::shared_ptr<TorrentAttribute> torrentAttrs =
         bittorrent::getTorrentAttrs(downloadContext_);
       bool metadataGetMode = torrentAttrs->metadata.empty();
       if(option_->getAsBool(PREF_DRY_RUN)) {
         throw DOWNLOAD_FAILURE_EXCEPTION
           ("Cancel BitTorrent download in dry-run context.");
       }
-      SharedHandle<BtRegistry> btRegistry = e->getBtRegistry();
+      std::shared_ptr<BtRegistry> btRegistry = e->getBtRegistry();
       if(btRegistry->getDownloadContext(torrentAttrs->infoHash)) {
         // TODO If metadataGetMode == false and each FileEntry has
         // URI, then go without BT.
@@ -320,7 +320,7 @@ void RequestGroup::createInitialCommand
       }
 
       DefaultBtProgressInfoFile* progressInfoFilePtr = 0;
-      SharedHandle<BtProgressInfoFile> progressInfoFile;
+      std::shared_ptr<BtProgressInfoFile> progressInfoFile;
       if(!metadataGetMode) {
         progressInfoFilePtr = new DefaultBtProgressInfoFile(downloadContext_,
                                                             pieceStorage_,
@@ -328,7 +328,7 @@ void RequestGroup::createInitialCommand
         progressInfoFile.reset(progressInfoFilePtr);
       }
 
-      SharedHandle<BtRuntime> btRuntime(new BtRuntime());
+      std::shared_ptr<BtRuntime> btRuntime(new BtRuntime());
       btRuntime->setMaxPeers(option_->getAsInt(PREF_BT_MAX_PEERS));
       btRuntime_ = btRuntime.get();
       if(progressInfoFilePtr) {
@@ -339,7 +339,7 @@ void RequestGroup::createInitialCommand
       peerStoragePtr->setBtRuntime(btRuntime);
       peerStoragePtr->setPieceStorage(pieceStorage_);
       peerStorage_ = peerStoragePtr;
-      SharedHandle<PeerStorage> peerStorage(peerStoragePtr);
+      std::shared_ptr<PeerStorage> peerStorage(peerStoragePtr);
       if(progressInfoFilePtr) {
         progressInfoFilePtr->setPeerStorage(peerStorage);
       }
@@ -352,11 +352,11 @@ void RequestGroup::createInitialCommand
       btAnnouncePtr->setUserDefinedInterval
         (option_->getAsInt(PREF_BT_TRACKER_INTERVAL));
       btAnnouncePtr->shuffleAnnounce();
-      SharedHandle<BtAnnounce> btAnnounce(btAnnouncePtr);
+      std::shared_ptr<BtAnnounce> btAnnounce(btAnnouncePtr);
 
       assert(!btRegistry->get(gid_->getNumericId()));
       btRegistry->put
-        (gid_->getNumericId(), SharedHandle<BtObject>
+        (gid_->getNumericId(), std::shared_ptr<BtObject>
          (new BtObject
           (downloadContext_,
            pieceStorage_,
@@ -385,7 +385,7 @@ void RequestGroup::createInitialCommand
                           " recommended. See --enable-dht option."));
         }
 
-        SharedHandle<CheckIntegrityEntry> entry
+        std::shared_ptr<CheckIntegrityEntry> entry
           (new BtCheckIntegrityEntry(this));
         entry->onDownloadIncomplete(commands, e);
 
@@ -463,7 +463,7 @@ void RequestGroup::createInitialCommand
           e->addCommand(command);
         }
       }
-      SharedHandle<CheckIntegrityEntry> entry(new BtCheckIntegrityEntry(this));
+      std::shared_ptr<CheckIntegrityEntry> entry(new BtCheckIntegrityEntry(this));
       // --bt-seed-unverified=true is given and download has completed, skip
       // validation for piece hashes.
       if(option_->getAsBool(PREF_BT_SEED_UNVERIFIED) &&
@@ -489,12 +489,12 @@ void RequestGroup::createInitialCommand
                downloadContext_->getBasePath().c_str()),
            error_code::DUPLICATE_DOWNLOAD);
       }
-      SharedHandle<BtProgressInfoFile> progressInfoFile
+      std::shared_ptr<BtProgressInfoFile> progressInfoFile
         (new DefaultBtProgressInfoFile
-         (downloadContext_, SharedHandle<PieceStorage>(), option_.get()));
+         (downloadContext_, std::shared_ptr<PieceStorage>(), option_.get()));
       adjustFilename(progressInfoFile);
       initPieceStorage();
-      SharedHandle<CheckIntegrityEntry> checkEntry =
+      std::shared_ptr<CheckIntegrityEntry> checkEntry =
         createCheckIntegrityEntry();
       if(checkEntry) {
         processCheckIntegrityEntry(commands, checkEntry, e);
@@ -520,7 +520,7 @@ void RequestGroup::createInitialCommand
     if(downloadContext_->getFileEntries().size() > 1) {
       pieceStorage_->setupFileFilter();
     }
-    SharedHandle<BtProgressInfoFile> progressInfoFile
+    std::shared_ptr<BtProgressInfoFile> progressInfoFile
       (new DefaultBtProgressInfoFile(downloadContext_,
                                      pieceStorage_,
                                      option_.get()));
@@ -547,7 +547,7 @@ void RequestGroup::createInitialCommand
       }
     }
     progressInfoFile_ = progressInfoFile;
-    SharedHandle<CheckIntegrityEntry> checkIntegrityEntry
+    std::shared_ptr<CheckIntegrityEntry> checkIntegrityEntry
       (new StreamCheckIntegrityEntry(this));
     processCheckIntegrityEntry(commands, checkIntegrityEntry, e);
   }
@@ -555,7 +555,7 @@ void RequestGroup::createInitialCommand
 
 void RequestGroup::processCheckIntegrityEntry
 (std::vector<Command*>& commands,
- const SharedHandle<CheckIntegrityEntry>& entry,
+ const std::shared_ptr<CheckIntegrityEntry>& entry,
  DownloadEngine* e)
 {
   int64_t actualFileSize = pieceStorage_->getDiskAdaptor()->size();
@@ -584,7 +584,7 @@ void RequestGroup::processCheckIntegrityEntry
 
 void RequestGroup::initPieceStorage()
 {
-  SharedHandle<PieceStorage> tempPieceStorage;
+  std::shared_ptr<PieceStorage> tempPieceStorage;
   if(downloadContext_->knowsTotalLength() &&
      // Following conditions are needed for chunked encoding with
      // content-length = 0. Google's dl server used this before.
@@ -596,7 +596,7 @@ void RequestGroup::initPieceStorage()
 #ifdef ENABLE_BITTORRENT
     DefaultPieceStorage* ps =
       new DefaultPieceStorage(downloadContext_, option_.get());
-    SharedHandle<PieceStorage> psHolder(ps);
+    std::shared_ptr<PieceStorage> psHolder(ps);
     if(downloadContext_->hasAttribute(CTX_ATTR_BT)) {
       if(isUriSuppliedForRequsetFileEntry
          (downloadContext_->getFileEntries().begin(),
@@ -605,7 +605,7 @@ void RequestGroup::initPieceStorage()
         // integrated downloads. Currently multi-file integrated
         // download is not supported.
         A2_LOG_DEBUG("Using LongestSequencePieceSelector");
-        SharedHandle<PieceSelector> longestPieceSelector
+        std::shared_ptr<PieceSelector> longestPieceSelector
           (new LongestSequencePieceSelector());
         ps->setPieceSelector(longestPieceSelector);
       }
@@ -618,7 +618,7 @@ void RequestGroup::initPieceStorage()
         if(!result.empty()) {
           std::random_shuffle(result.begin(), result.end(),
                               *(SimpleRandomizer::getInstance().get()));
-          SharedHandle<PriorityPieceSelector> priSelector
+          std::shared_ptr<PriorityPieceSelector> priSelector
             (new PriorityPieceSelector(ps->getPieceSelector()));
           priSelector->setPriorityPiece(result.begin(), result.end());
           ps->setPieceSelector(priSelector);
@@ -628,7 +628,7 @@ void RequestGroup::initPieceStorage()
 #else // !ENABLE_BITTORRENT
     DefaultPieceStorage* ps =
       new DefaultPieceStorage(downloadContext_, option_.get());
-    SharedHandle<PieceStorage> psHolder(ps);
+    std::shared_ptr<PieceStorage> psHolder(ps);
 #endif // !ENABLE_BITTORRENT
     if(requestGroupMan_) {
       ps->setWrDiskCache(requestGroupMan_->getWrDiskCache());
@@ -640,14 +640,14 @@ void RequestGroup::initPieceStorage()
   } else {
     UnknownLengthPieceStorage* ps =
       new UnknownLengthPieceStorage(downloadContext_);
-    SharedHandle<PieceStorage> psHolder(ps);
+    std::shared_ptr<PieceStorage> psHolder(ps);
     if(diskWriterFactory_) {
       ps->setDiskWriterFactory(diskWriterFactory_);
     }
     tempPieceStorage.swap(psHolder);
   }
   tempPieceStorage->initStorage();
-  SharedHandle<SegmentMan> tempSegmentMan(new SegmentMan(downloadContext_,
+  std::shared_ptr<SegmentMan> tempSegmentMan(new SegmentMan(downloadContext_,
                                                          tempPieceStorage));
 
   pieceStorage_.swap(tempPieceStorage);
@@ -679,7 +679,7 @@ bool RequestGroup::downloadFinishedByFileLength()
 }
 
 void RequestGroup::adjustFilename
-(const SharedHandle<BtProgressInfoFile>& infoFile)
+(const std::shared_ptr<BtProgressInfoFile>& infoFile)
 {
   if(!isPreLocalFileCheckEnabled()) {
     // OK, no need to care about filename.
@@ -715,7 +715,7 @@ void RequestGroup::adjustFilename
 }
 
 void RequestGroup::removeDefunctControlFile
-(const SharedHandle<BtProgressInfoFile>& progressInfoFile)
+(const std::shared_ptr<BtProgressInfoFile>& progressInfoFile)
 {
   // Remove the control file if download file doesn't exist
   if(progressInfoFile->exists() &&
@@ -728,7 +728,7 @@ void RequestGroup::removeDefunctControlFile
 }
 
 void RequestGroup::loadAndOpenFile
-(const SharedHandle<BtProgressInfoFile>& progressInfoFile)
+(const std::shared_ptr<BtProgressInfoFile>& progressInfoFile)
 {
   try {
     if(!isPreLocalFileCheckEnabled()) {
@@ -1033,7 +1033,7 @@ void RequestGroup::preDownloadProcessing()
   A2_LOG_DEBUG(fmt("Finding PreDownloadHandler for path %s.",
                    getFirstFilePath().c_str()));
   try {
-    for(std::vector<SharedHandle<PreDownloadHandler> >::const_iterator itr =
+    for(std::vector<std::shared_ptr<PreDownloadHandler> >::const_iterator itr =
           preDownloadHandlers_.begin(), eoi = preDownloadHandlers_.end();
         itr != eoi; ++itr) {
       if((*itr)->canHandle(this)) {
@@ -1050,12 +1050,12 @@ void RequestGroup::preDownloadProcessing()
 }
 
 void RequestGroup::postDownloadProcessing
-(std::vector<SharedHandle<RequestGroup> >& groups)
+(std::vector<std::shared_ptr<RequestGroup> >& groups)
 {
   A2_LOG_DEBUG(fmt("Finding PostDownloadHandler for path %s.",
                    getFirstFilePath().c_str()));
   try {
-    for(std::vector<SharedHandle<PostDownloadHandler> >::const_iterator itr =
+    for(std::vector<std::shared_ptr<PostDownloadHandler> >::const_iterator itr =
           postDownloadHandlers_.begin(), eoi = postDownloadHandlers_.end();
         itr != eoi; ++itr) {
       if((*itr)->canHandle(this)) {
@@ -1107,25 +1107,25 @@ bool RequestGroup::isDependencyResolved()
   return dependency_->resolve();
 }
 
-void RequestGroup::dependsOn(const SharedHandle<Dependency>& dep)
+void RequestGroup::dependsOn(const std::shared_ptr<Dependency>& dep)
 {
   dependency_ = dep;
 }
 
 void RequestGroup::setDiskWriterFactory
-(const SharedHandle<DiskWriterFactory>& diskWriterFactory)
+(const std::shared_ptr<DiskWriterFactory>& diskWriterFactory)
 {
   diskWriterFactory_ = diskWriterFactory;
 }
 
 void RequestGroup::addPostDownloadHandler
-(const SharedHandle<PostDownloadHandler>& handler)
+(const std::shared_ptr<PostDownloadHandler>& handler)
 {
   postDownloadHandlers_.push_back(handler);
 }
 
 void RequestGroup::addPreDownloadHandler
-(const SharedHandle<PreDownloadHandler>& handler)
+(const std::shared_ptr<PreDownloadHandler>& handler)
 {
   preDownloadHandlers_.push_back(handler);
 }
@@ -1140,13 +1140,13 @@ void RequestGroup::clearPreDownloadHandler()
   preDownloadHandlers_.clear();
 }
 
-void RequestGroup::setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage)
+void RequestGroup::setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
 
 void RequestGroup::setProgressInfoFile
-(const SharedHandle<BtProgressInfoFile>& progressInfoFile)
+(const std::shared_ptr<BtProgressInfoFile>& progressInfoFile)
 {
   progressInfoFile_ = progressInfoFile;
 }
@@ -1158,12 +1158,12 @@ bool RequestGroup::needsFileAllocation() const
     !pieceStorage_->getDiskAdaptor()->fileAllocationIterator()->finished();
 }
 
-SharedHandle<DownloadResult> RequestGroup::createDownloadResult() const
+std::shared_ptr<DownloadResult> RequestGroup::createDownloadResult() const
 {
   A2_LOG_DEBUG(fmt("GID#%s - Creating DownloadResult.",
                    gid_->toHex().c_str()));
   TransferStat st = calculateStat();
-  SharedHandle<DownloadResult> res(new DownloadResult());
+  std::shared_ptr<DownloadResult> res(new DownloadResult());
   res->gid = gid_;
   res->fileEntries = downloadContext_->getFileEntries();
   res->inMemoryDownload = inMemoryDownload_;
@@ -1207,7 +1207,7 @@ void RequestGroup::reportDownloadFinished()
     int64_t completedLength = getCompletedLength();
     double shareRatio = completedLength == 0 ? 0.0 :
       1.0*stat.allTimeUploadLength/completedLength;
-    SharedHandle<TorrentAttribute> attrs =
+    std::shared_ptr<TorrentAttribute> attrs =
       bittorrent::getTorrentAttrs(downloadContext_);
     if(!attrs->metadata.empty()) {
       A2_LOG_NOTICE(fmt(MSG_SHARE_RATIO_REPORT,
@@ -1219,7 +1219,7 @@ void RequestGroup::reportDownloadFinished()
 #endif // ENABLE_BITTORRENT
 }
 
-void RequestGroup::setURISelector(const SharedHandle<URISelector>& uriSelector)
+void RequestGroup::setURISelector(const std::shared_ptr<URISelector>& uriSelector)
 {
   uriSelector_ = uriSelector;
 }
@@ -1290,7 +1290,7 @@ void RequestGroup::removeControlFile() const
 }
 
 void RequestGroup::setDownloadContext
-(const SharedHandle<DownloadContext>& downloadContext)
+(const std::shared_ptr<DownloadContext>& downloadContext)
 {
   downloadContext_ = downloadContext;
   if(downloadContext_) {
diff --git a/src/RequestGroup.h b/src/RequestGroup.h
index 7713d4ba..3fe0ce33 100644
--- a/src/RequestGroup.h
+++ b/src/RequestGroup.h
@@ -40,8 +40,8 @@
 #include <string>
 #include <algorithm>
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TransferStat.h"
 #include "TimeA2.h"
 #include "Request.h"
@@ -88,11 +88,11 @@ public:
     STATE_ACTIVE
   };
 private:
-  SharedHandle<GroupId> gid_;
+  std::shared_ptr<GroupId> gid_;
 
   int state_;
 
-  SharedHandle<Option> option_;
+  std::shared_ptr<Option> option_;
 
   int numConcurrentCommand_;
 
@@ -105,19 +105,19 @@ private:
 
   int numCommand_;
 
-  SharedHandle<SegmentMan> segmentMan_;
+  std::shared_ptr<SegmentMan> segmentMan_;
 
-  SharedHandle<DownloadContext> downloadContext_;
+  std::shared_ptr<DownloadContext> downloadContext_;
 
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
 
   bool saveControlFile_;
 
-  SharedHandle<BtProgressInfoFile> progressInfoFile_;
+  std::shared_ptr<BtProgressInfoFile> progressInfoFile_;
 
-  SharedHandle<DiskWriterFactory> diskWriterFactory_;
+  std::shared_ptr<DiskWriterFactory> diskWriterFactory_;
 
-  SharedHandle<Dependency> dependency_;
+  std::shared_ptr<Dependency> dependency_;
 
   bool fileAllocationEnabled_;
 
@@ -131,11 +131,11 @@ private:
 
   bool pauseRequested_;
 
-  std::vector<SharedHandle<PreDownloadHandler> > preDownloadHandlers_;
+  std::vector<std::shared_ptr<PreDownloadHandler> > preDownloadHandlers_;
 
-  std::vector<SharedHandle<PostDownloadHandler> > postDownloadHandlers_;
+  std::vector<std::shared_ptr<PostDownloadHandler> > postDownloadHandlers_;
 
-  SharedHandle<URISelector> uriSelector_;
+  std::shared_ptr<URISelector> uriSelector_;
 
   Time lastModifiedTime_;
 
@@ -172,7 +172,7 @@ private:
   // RequestGroup.
   a2_gid_t belongsToGID_;
 
-  SharedHandle<MetadataInfo> metadataInfo_;
+  std::shared_ptr<MetadataInfo> metadataInfo_;
 
   RequestGroupMan* requestGroupMan_;
 
@@ -195,22 +195,22 @@ private:
   error_code::Value downloadResult() const;
 
   void removeDefunctControlFile
-  (const SharedHandle<BtProgressInfoFile>& progressInfoFile);
+  (const std::shared_ptr<BtProgressInfoFile>& progressInfoFile);
 
 public:
-  RequestGroup(const SharedHandle<GroupId>& gid,
-               const SharedHandle<Option>& option);
+  RequestGroup(const std::shared_ptr<GroupId>& gid,
+               const std::shared_ptr<Option>& option);
 
   ~RequestGroup();
 
   bool isCheckIntegrityReady();
 
-  const SharedHandle<SegmentMan>& getSegmentMan() const
+  const std::shared_ptr<SegmentMan>& getSegmentMan() const
   {
     return segmentMan_;
   }
 
-  SharedHandle<CheckIntegrityEntry> createCheckIntegrityEntry();
+  std::shared_ptr<CheckIntegrityEntry> createCheckIntegrityEntry();
 
   // Returns first bootstrap commands to initiate a download.
   // If this is HTTP/FTP download and file size is unknown, only 1 command
@@ -265,30 +265,30 @@ public:
     return gid_->getNumericId();
   }
 
-  const SharedHandle<GroupId>& getGroupId() const
+  const std::shared_ptr<GroupId>& getGroupId() const
   {
     return gid_;
   }
 
   TransferStat calculateStat() const;
 
-  const SharedHandle<DownloadContext>& getDownloadContext() const
+  const std::shared_ptr<DownloadContext>& getDownloadContext() const
   {
     return downloadContext_;
   }
 
   // This function also calls
   // downloadContext->setOwnerRequestGroup(this).
-  void setDownloadContext(const SharedHandle<DownloadContext>& downloadContext);
+  void setDownloadContext(const std::shared_ptr<DownloadContext>& downloadContext);
 
-  const SharedHandle<PieceStorage>& getPieceStorage() const
+  const std::shared_ptr<PieceStorage>& getPieceStorage() const
   {
     return pieceStorage_;
   }
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 
-  void setProgressInfoFile(const SharedHandle<BtProgressInfoFile>& progressInfoFile);
+  void setProgressInfoFile(const std::shared_ptr<BtProgressInfoFile>& progressInfoFile);
 
   void increaseStreamCommand();
 
@@ -310,9 +310,9 @@ public:
   }
 
   // TODO is it better to move the following 2 methods to SingleFileDownloadContext?
-  void setDiskWriterFactory(const SharedHandle<DiskWriterFactory>& diskWriterFactory);
+  void setDiskWriterFactory(const std::shared_ptr<DiskWriterFactory>& diskWriterFactory);
 
-  const SharedHandle<DiskWriterFactory>& getDiskWriterFactory() const
+  const std::shared_ptr<DiskWriterFactory>& getDiskWriterFactory() const
   {
     return diskWriterFactory_;
   }
@@ -365,26 +365,26 @@ public:
     return pauseRequested_;
   }
 
-  void dependsOn(const SharedHandle<Dependency>& dep);
+  void dependsOn(const std::shared_ptr<Dependency>& dep);
 
   bool isDependencyResolved();
 
   void releaseRuntimeResource(DownloadEngine* e);
 
-  void postDownloadProcessing(std::vector<SharedHandle<RequestGroup> >& groups);
+  void postDownloadProcessing(std::vector<std::shared_ptr<RequestGroup> >& groups);
 
-  void addPostDownloadHandler(const SharedHandle<PostDownloadHandler>& handler);
+  void addPostDownloadHandler(const std::shared_ptr<PostDownloadHandler>& handler);
 
   void clearPostDownloadHandler();
 
   void preDownloadProcessing();
 
-  void addPreDownloadHandler(const SharedHandle<PreDownloadHandler>& handler);
+  void addPreDownloadHandler(const std::shared_ptr<PreDownloadHandler>& handler);
 
   void clearPreDownloadHandler();
 
   void processCheckIntegrityEntry(std::vector<Command*>& commands,
-                                  const SharedHandle<CheckIntegrityEntry>& entry,
+                                  const std::shared_ptr<CheckIntegrityEntry>& entry,
                                   DownloadEngine* e);
 
   // Initializes pieceStorage_ and segmentMan_.  We guarantee that
@@ -396,24 +396,24 @@ public:
 
   bool downloadFinishedByFileLength();
 
-  void loadAndOpenFile(const SharedHandle<BtProgressInfoFile>& progressInfoFile);
+  void loadAndOpenFile(const std::shared_ptr<BtProgressInfoFile>& progressInfoFile);
 
   void shouldCancelDownloadForSafety();
 
-  void adjustFilename(const SharedHandle<BtProgressInfoFile>& infoFile);
+  void adjustFilename(const std::shared_ptr<BtProgressInfoFile>& infoFile);
 
-  SharedHandle<DownloadResult> createDownloadResult() const;
+  std::shared_ptr<DownloadResult> createDownloadResult() const;
 
-  const SharedHandle<Option>& getOption() const
+  const std::shared_ptr<Option>& getOption() const
   {
     return option_;
   }
 
   void reportDownloadFinished();
 
-  void setURISelector(const SharedHandle<URISelector>& uriSelector);
+  void setURISelector(const std::shared_ptr<URISelector>& uriSelector);
 
-  const SharedHandle<URISelector>& getURISelector() const
+  const std::shared_ptr<URISelector>& getURISelector() const
   {
     return uriSelector_;
   }
@@ -534,12 +534,12 @@ public:
 
   bool p2pInvolved() const;
 
-  void setMetadataInfo(const SharedHandle<MetadataInfo>& info)
+  void setMetadataInfo(const std::shared_ptr<MetadataInfo>& info)
   {
     metadataInfo_ = info;
   }
 
-  const SharedHandle<MetadataInfo>& getMetadataInfo() const
+  const std::shared_ptr<MetadataInfo>& getMetadataInfo() const
   {
     return metadataInfo_;
   }
diff --git a/src/RequestGroupCriteria.h b/src/RequestGroupCriteria.h
index 7cbaa332..7109a589 100644
--- a/src/RequestGroupCriteria.h
+++ b/src/RequestGroupCriteria.h
@@ -36,7 +36,6 @@
 #define D_REQUEST_GROUP_CRITERIA_H
 
 #include "common.h"
-#include "SharedHandle.h"
 
 namespace aria2 {
 
diff --git a/src/RequestGroupMan.cc b/src/RequestGroupMan.cc
index 60ededbb..c4b3c683 100644
--- a/src/RequestGroupMan.cc
+++ b/src/RequestGroupMan.cc
@@ -97,7 +97,7 @@ void appendReservedGroup(RequestGroupList& list,
 } // namespace
 
 RequestGroupMan::RequestGroupMan
-(const std::vector<SharedHandle<RequestGroup> >& requestGroups,
+(const std::vector<std::shared_ptr<RequestGroup> >& requestGroups,
  int maxSimultaneousDownloads,
  const Option* option)
   : maxSimultaneousDownloads_(maxSimultaneousDownloads),
@@ -132,20 +132,20 @@ bool RequestGroupMan::downloadFinished()
 }
 
 void RequestGroupMan::addRequestGroup
-(const SharedHandle<RequestGroup>& group)
+(const std::shared_ptr<RequestGroup>& group)
 {
   requestGroups_.push_back(group->getGID(), group);
 }
 
 void RequestGroupMan::addReservedGroup
-(const std::vector<SharedHandle<RequestGroup> >& groups)
+(const std::vector<std::shared_ptr<RequestGroup> >& groups)
 {
   requestQueueCheck();
   appendReservedGroup(reservedGroups_, groups.begin(), groups.end());
 }
 
 void RequestGroupMan::addReservedGroup
-(const SharedHandle<RequestGroup>& group)
+(const std::shared_ptr<RequestGroup>& group)
 {
   requestQueueCheck();
   reservedGroups_.push_back(group->getGID(), group);
@@ -153,7 +153,7 @@ void RequestGroupMan::addReservedGroup
 
 namespace {
 struct RequestGroupKeyFunc {
-  a2_gid_t operator()(const SharedHandle<RequestGroup>& rg) const
+  a2_gid_t operator()(const std::shared_ptr<RequestGroup>& rg) const
   {
     return rg->getGID();
   }
@@ -161,7 +161,7 @@ struct RequestGroupKeyFunc {
 } // namespace
 
 void RequestGroupMan::insertReservedGroup
-(size_t pos, const std::vector<SharedHandle<RequestGroup> >& groups)
+(size_t pos, const std::vector<std::shared_ptr<RequestGroup> >& groups)
 {
   requestQueueCheck();
   pos = std::min(reservedGroups_.size(), pos);
@@ -170,7 +170,7 @@ void RequestGroupMan::insertReservedGroup
 }
 
 void RequestGroupMan::insertReservedGroup
-(size_t pos, const SharedHandle<RequestGroup>& group)
+(size_t pos, const std::shared_ptr<RequestGroup>& group)
 {
   requestQueueCheck();
   pos = std::min(reservedGroups_.size(), pos);
@@ -182,9 +182,9 @@ size_t RequestGroupMan::countRequestGroup() const
   return requestGroups_.size();
 }
 
-SharedHandle<RequestGroup> RequestGroupMan::findGroup(a2_gid_t gid) const
+std::shared_ptr<RequestGroup> RequestGroupMan::findGroup(a2_gid_t gid) const
 {
-  SharedHandle<RequestGroup> rg = requestGroups_.get(gid);
+  std::shared_ptr<RequestGroup> rg = requestGroups_.get(gid);
   if(!rg) {
     rg = reservedGroups_.get(gid);
   }
@@ -211,7 +211,7 @@ bool RequestGroupMan::removeReservedGroup(a2_gid_t gid)
 namespace {
 
 void notifyDownloadEvent
-(DownloadEvent event, const SharedHandle<RequestGroup>& group)
+(DownloadEvent event, const std::shared_ptr<RequestGroup>& group)
 {
   // Check NULL to make unit test easier.
   if(SingletonHolder<Notifier>::instance()) {
@@ -224,7 +224,7 @@ void notifyDownloadEvent
 namespace {
 
 void executeStopHook
-(const SharedHandle<RequestGroup>& group,
+(const std::shared_ptr<RequestGroup>& group,
  const Option* option,
  error_code::Value result)
 {
@@ -256,9 +256,9 @@ private:
   DownloadEngine* e_;
   RequestGroupList& reservedGroups_;
 
-  void saveSignature(const SharedHandle<RequestGroup>& group)
+  void saveSignature(const std::shared_ptr<RequestGroup>& group)
   {
-    SharedHandle<Signature> sig =
+    std::shared_ptr<Signature> sig =
       group->getDownloadContext()->getSignature();
     if(sig && !sig->getBody().empty()) {
       // filename of signature file is the path to download file followed by
@@ -274,14 +274,14 @@ private:
 
   // Collect statistics during download in PeerStats and update/register
   // ServerStatMan
-  void collectStat(const SharedHandle<RequestGroup>& group)
+  void collectStat(const std::shared_ptr<RequestGroup>& group)
   {
     if(group->getSegmentMan()) {
       bool singleConnection =
         group->getSegmentMan()->getPeerStats().size() == 1;
-      const std::vector<SharedHandle<PeerStat> >& peerStats =
+      const std::vector<std::shared_ptr<PeerStat> >& peerStats =
         group->getSegmentMan()->getFastestPeerStats();
-      for(std::vector<SharedHandle<PeerStat> >::const_iterator i =
+      for(std::vector<std::shared_ptr<PeerStat> >::const_iterator i =
             peerStats.begin(), eoi = peerStats.end(); i != eoi; ++i) {
         if((*i)->getHostname().empty() || (*i)->getProtocol().empty()) {
           continue;
@@ -289,7 +289,7 @@ private:
         int speed = (*i)->getAvgDownloadSpeed();
         if (speed == 0) continue;
 
-        SharedHandle<ServerStat> ss =
+        std::shared_ptr<ServerStat> ss =
           e_->getRequestGroupMan()->getOrCreateServerStat((*i)->getHostname(),
                                                           (*i)->getProtocol());
         ss->increaseCounter();
@@ -315,7 +315,7 @@ public:
   {
     if(group->getNumCommand() == 0) {
       collectStat(group);
-      const SharedHandle<DownloadContext>& dctx = group->getDownloadContext();
+      const std::shared_ptr<DownloadContext>& dctx = group->getDownloadContext();
       // DownloadContext::resetDownloadStopTime() is only called when
       // download completed. If
       // DownloadContext::getDownloadStopTime().isZero() is true, then
@@ -342,7 +342,7 @@ public:
           } else {
             group->saveControlFile();
           }
-          std::vector<SharedHandle<RequestGroup> > nextGroups;
+          std::vector<std::shared_ptr<RequestGroup> > nextGroups;
           group->postDownloadProcessing(nextGroups);
           if(!nextGroups.empty()) {
             A2_LOG_DEBUG
@@ -360,9 +360,9 @@ public:
              dctx->hasAttribute(CTX_ATTR_BT)) {
             A2_LOG_INFO(fmt(MSG_REMOVING_UNSELECTED_FILE,
                             GroupId::toHex(group->getGID()).c_str()));
-            const std::vector<SharedHandle<FileEntry> >& files =
+            const std::vector<std::shared_ptr<FileEntry> >& files =
               dctx->getFileEntries();
-            for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
+            for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i =
                   files.begin(), eoi = files.end(); i != eoi; ++i) {
               if(!(*i)->isRequested()) {
                 if(File((*i)->getPath()).remove()) {
@@ -396,7 +396,7 @@ public:
         // TODO Should we have to prepend spend uris to remaining uris
         // in case PREF_REUSE_URI is disabed?
       } else {
-        SharedHandle<DownloadResult> dr = group->createDownloadResult();
+        std::shared_ptr<DownloadResult> dr = group->createDownloadResult();
         e_->getRequestGroupMan()->addDownloadResult(dr);
         executeStopHook(group, e_->getOption(), dr->result);
         group->releaseRuntimeResource(e_);
@@ -421,11 +421,11 @@ void RequestGroupMan::removeStoppedGroup(DownloadEngine* e)
 }
 
 void RequestGroupMan::configureRequestGroup
-(const SharedHandle<RequestGroup>& requestGroup) const
+(const std::shared_ptr<RequestGroup>& requestGroup) const
 {
   const std::string& uriSelectorValue =
     requestGroup->getOption()->get(PREF_URI_SELECTOR);
-  SharedHandle<URISelector> sel;
+  std::shared_ptr<URISelector> sel;
   if(uriSelectorValue == V_FEEDBACK) {
     sel.reset(new FeedbackURISelector(serverStatMan_));
   } else if(uriSelectorValue == V_INORDER) {
@@ -439,7 +439,7 @@ void RequestGroupMan::configureRequestGroup
 }
 
 namespace {
-void createInitialCommand(const SharedHandle<RequestGroup>& requestGroup,
+void createInitialCommand(const std::shared_ptr<RequestGroup>& requestGroup,
                           std::vector<Command*>& commands,
                           DownloadEngine* e)
 {
@@ -455,11 +455,11 @@ void RequestGroupMan::fillRequestGroupFromReserver(DownloadEngine* e)
   }
   int count = 0;
   int num = maxSimultaneousDownloads_-requestGroups_.size();
-  std::vector<SharedHandle<RequestGroup> > pending;
+  std::vector<std::shared_ptr<RequestGroup> > pending;
 
   while(count < num && (uriListParser_ || !reservedGroups_.empty())) {
     if(uriListParser_ && reservedGroups_.empty()) {
-      std::vector<SharedHandle<RequestGroup> > groups;
+      std::vector<std::shared_ptr<RequestGroup> > groups;
       // May throw exception
       bool ok = createRequestGroupFromUriListParser(groups, option_,
                                                     uriListParser_.get());
@@ -472,7 +472,7 @@ void RequestGroupMan::fillRequestGroupFromReserver(DownloadEngine* e)
         }
       }
     }
-    SharedHandle<RequestGroup> groupToAdd = *reservedGroups_.begin();
+    std::shared_ptr<RequestGroup> groupToAdd = *reservedGroups_.begin();
     reservedGroups_.pop_front();
     if((keepRunning_ && groupToAdd->isPauseRequested()) ||
        !groupToAdd->isDependencyResolved()) {
@@ -525,7 +525,7 @@ void RequestGroupMan::save()
 {
   for(RequestGroupList::iterator itr = requestGroups_.begin(),
         eoi = requestGroups_.end(); itr != eoi; ++itr) {
-    const SharedHandle<RequestGroup>& rg = *itr;
+    const std::shared_ptr<RequestGroup>& rg = *itr;
     if(rg->allDownloadFinished() &&
        !rg->getDownloadContext()->isChecksumVerificationNeeded()) {
       rg->removeControlFile();
@@ -557,7 +557,7 @@ RequestGroupMan::DownloadStat RequestGroupMan::getDownloadStat() const
   for(DownloadResultList::const_iterator itr =
         downloadResults_.begin(), eoi = downloadResults_.end(); itr != eoi;
       ++itr) {
-    const SharedHandle<DownloadResult>& dr = *itr;
+    const std::shared_ptr<DownloadResult>& dr = *itr;
     if(dr->belongsTo != 0) {
       continue;
     }
@@ -646,7 +646,7 @@ void RequestGroupMan::showDownloadResults(OutputFile& o, bool full) const
   for(DownloadResultList::const_iterator itr =
         downloadResults_.begin(), eoi = downloadResults_.end(); itr != eoi;
       ++itr) {
-    const SharedHandle<DownloadResult>& dr = *itr;
+    const std::shared_ptr<DownloadResult>& dr = *itr;
     if(dr->belongsTo != 0) {
       continue;
     }
@@ -697,7 +697,7 @@ namespace {
 void formatDownloadResultCommon
 (std::ostream& o,
  const char* status,
- const SharedHandle<DownloadResult>& downloadResult)
+ const std::shared_ptr<DownloadResult>& downloadResult)
 {
   o << std::setw(3) << downloadResult->gid->toAbbrevHex() << "|"
     << std::setw(4) << status << "|"
@@ -716,16 +716,16 @@ void formatDownloadResultCommon
 void RequestGroupMan::formatDownloadResultFull
 (OutputFile& out,
  const char* status,
- const SharedHandle<DownloadResult>& downloadResult) const
+ const std::shared_ptr<DownloadResult>& downloadResult) const
 {
   BitfieldMan bt(downloadResult->pieceLength, downloadResult->totalLength);
   bt.setBitfield(reinterpret_cast<const unsigned char*>
                  (downloadResult->bitfield.data()),
                  downloadResult->bitfield.size());
   bool head = true;
-  const std::vector<SharedHandle<FileEntry> >& fileEntries =
+  const std::vector<std::shared_ptr<FileEntry> >& fileEntries =
     downloadResult->fileEntries;
-  for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
+  for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i =
         fileEntries.begin(), eoi = fileEntries.end(); i != eoi; ++i) {
     if(!(*i)->isRequested()) {
       continue;
@@ -758,11 +758,11 @@ void RequestGroupMan::formatDownloadResultFull
 
 std::string RequestGroupMan::formatDownloadResult
 (const char* status,
- const SharedHandle<DownloadResult>& downloadResult) const
+ const std::shared_ptr<DownloadResult>& downloadResult) const
 {
   std::stringstream o;
   formatDownloadResultCommon(o, status, downloadResult);
-  const std::vector<SharedHandle<FileEntry> >& fileEntries =
+  const std::vector<std::shared_ptr<FileEntry> >& fileEntries =
     downloadResult->fileEntries;
   writeFilePath(fileEntries.begin(), fileEntries.end(), o,
                 downloadResult->inMemoryDownload);
@@ -795,9 +795,9 @@ bool RequestGroupMan::isSameFileBeingDownloaded(RequestGroup* requestGroup) cons
   std::vector<std::string> files;
   for(RequestGroupList::const_iterator itr = requestGroups_.begin(),
         eoi = requestGroups_.end(); itr != eoi; ++itr) {
-    const SharedHandle<RequestGroup>& rg = *itr;
+    const std::shared_ptr<RequestGroup>& rg = *itr;
     if(rg.get() != requestGroup) {
-      const std::vector<SharedHandle<FileEntry> >& entries =
+      const std::vector<std::shared_ptr<FileEntry> >& entries =
         rg->getDownloadContext()->getFileEntries();
       std::transform(entries.begin(), entries.end(),
                      std::back_inserter(files),
@@ -805,7 +805,7 @@ bool RequestGroupMan::isSameFileBeingDownloaded(RequestGroup* requestGroup) cons
     }
   }
   std::sort(files.begin(), files.end());
-  const std::vector<SharedHandle<FileEntry> >& entries =
+  const std::vector<std::shared_ptr<FileEntry> >& entries =
     requestGroup->getDownloadContext()->getFileEntries();
   return sameFilePathExists(files.begin(), files.end(),
                             entries.begin(), entries.end());
@@ -833,7 +833,7 @@ TransferStat RequestGroupMan::calculateStat()
   return netStat_.toTransferStat();
 }
 
-SharedHandle<DownloadResult>
+std::shared_ptr<DownloadResult>
 RequestGroupMan::findDownloadResult(a2_gid_t gid) const
 {
   return downloadResults_.get(gid);
@@ -844,7 +844,7 @@ bool RequestGroupMan::removeDownloadResult(a2_gid_t gid)
   return downloadResults_.remove(gid);
 }
 
-void RequestGroupMan::addDownloadResult(const SharedHandle<DownloadResult>& dr)
+void RequestGroupMan::addDownloadResult(const std::shared_ptr<DownloadResult>& dr)
 {
   bool rv = downloadResults_.push_back(dr->gid->getNumericId(), dr);
   assert(rv);
@@ -852,7 +852,7 @@ void RequestGroupMan::addDownloadResult(const SharedHandle<DownloadResult>& dr)
     DownloadResultList::iterator i = downloadResults_.begin();
     // Save last encountered error code so that we can report it
     // later.
-    const SharedHandle<DownloadResult>& dr = *i;
+    const std::shared_ptr<DownloadResult>& dr = *i;
     if(dr->belongsTo == 0 && dr->result != error_code::FINISHED) {
       removedLastErrorResult_ = dr->result;
       ++removedErrorResult_;
@@ -866,18 +866,18 @@ void RequestGroupMan::purgeDownloadResult()
   downloadResults_.clear();
 }
 
-SharedHandle<ServerStat>
+std::shared_ptr<ServerStat>
 RequestGroupMan::findServerStat(const std::string& hostname,
                                 const std::string& protocol) const
 {
   return serverStatMan_->find(hostname, protocol);
 }
 
-SharedHandle<ServerStat>
+std::shared_ptr<ServerStat>
 RequestGroupMan::getOrCreateServerStat(const std::string& hostname,
                                        const std::string& protocol)
 {
-  SharedHandle<ServerStat> ss = findServerStat(hostname, protocol);
+  std::shared_ptr<ServerStat> ss = findServerStat(hostname, protocol);
   if(!ss) {
     ss.reset(new ServerStat(hostname, protocol));
     addServerStat(ss);
@@ -885,7 +885,7 @@ RequestGroupMan::getOrCreateServerStat(const std::string& hostname,
   return ss;
 }
 
-bool RequestGroupMan::addServerStat(const SharedHandle<ServerStat>& serverStat)
+bool RequestGroupMan::addServerStat(const std::shared_ptr<ServerStat>& serverStat)
 {
   return serverStatMan_->add(serverStat);
 }
@@ -927,7 +927,7 @@ void RequestGroupMan::getUsedHosts
   std::vector<Triplet<size_t, int, std::string> > tempHosts;
   for(RequestGroupList::const_iterator i = requestGroups_.begin(),
         eoi = requestGroups_.end(); i != eoi; ++i) {
-    const SharedHandle<RequestGroup>& rg = *i;
+    const std::shared_ptr<RequestGroup>& rg = *i;
     const FileEntry::InFlightRequestSet& inFlightReqs =
       rg->getDownloadContext()->getFirstFileEntry()->getInFlightRequests();
     for(FileEntry::InFlightRequestSet::iterator j =
@@ -948,7 +948,7 @@ void RequestGroupMan::getUsedHosts
         if(k == eok) {
           std::string protocol = uri::getFieldString(us, USR_SCHEME,
                                                      (*j)->getUri().c_str());
-          SharedHandle<ServerStat> ss = findServerStat(host, protocol);
+          std::shared_ptr<ServerStat> ss = findServerStat(host, protocol);
           int invDlSpeed = (ss && ss->isOK()) ?
             -(static_cast<int>(ss->getDownloadSpeed())) : 0;
           tempHosts.push_back(makeTriplet(1, invDlSpeed, host));
@@ -962,7 +962,7 @@ void RequestGroupMan::getUsedHosts
 }
 
 void RequestGroupMan::setUriListParser
-(const SharedHandle<UriListParser>& uriListParser)
+(const std::shared_ptr<UriListParser>& uriListParser)
 {
   uriListParser_ = uriListParser;
 }
diff --git a/src/RequestGroupMan.h b/src/RequestGroupMan.h
index ab595372..21df6a76 100644
--- a/src/RequestGroupMan.h
+++ b/src/RequestGroupMan.h
@@ -41,8 +41,8 @@
 #include <deque>
 #include <vector>
 #include <map>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "DownloadResult.h"
 #include "TransferStat.h"
 #include "RequestGroup.h"
@@ -62,9 +62,9 @@ class UriListParser;
 class WrDiskCache;
 
 typedef IndexedList<a2_gid_t,
-                    SharedHandle<RequestGroup> > RequestGroupList;
+                    std::shared_ptr<RequestGroup> > RequestGroupList;
 typedef IndexedList<a2_gid_t,
-                    SharedHandle<DownloadResult> > DownloadResultList;
+                    std::shared_ptr<DownloadResult> > DownloadResultList;
 
 class RequestGroupMan {
 private:
@@ -76,7 +76,7 @@ private:
 
   const Option* option_;
 
-  SharedHandle<ServerStatMan> serverStatMan_;
+  std::shared_ptr<ServerStatMan> serverStatMan_;
 
   int maxOverallDownloadSpeedLimit_;
 
@@ -100,27 +100,27 @@ private:
   size_t maxDownloadResult_;
 
   // UriListParser for deferred input.
-  SharedHandle<UriListParser> uriListParser_;
+  std::shared_ptr<UriListParser> uriListParser_;
 
   WrDiskCache* wrDiskCache_;
 
   void formatDownloadResultFull
   (OutputFile& out,
    const char* status,
-   const SharedHandle<DownloadResult>& downloadResult) const;
+   const std::shared_ptr<DownloadResult>& downloadResult) const;
 
   std::string formatDownloadResult
   (const char* status,
-   const SharedHandle<DownloadResult>& downloadResult) const;
+   const std::shared_ptr<DownloadResult>& downloadResult) const;
 
   void configureRequestGroup
-  (const SharedHandle<RequestGroup>& requestGroup) const;
+  (const std::shared_ptr<RequestGroup>& requestGroup) const;
 
-  void addRequestGroupIndex(const SharedHandle<RequestGroup>& group);
+  void addRequestGroupIndex(const std::shared_ptr<RequestGroup>& group);
   void addRequestGroupIndex
-  (const std::vector<SharedHandle<RequestGroup> >& groups);
+  (const std::vector<std::shared_ptr<RequestGroup> >& groups);
 public:
-  RequestGroupMan(const std::vector<SharedHandle<RequestGroup> >& requestGroups,
+  RequestGroupMan(const std::vector<std::shared_ptr<RequestGroup> >& requestGroups,
                   int maxSimultaneousDownloads,
                   const Option* option);
 
@@ -143,16 +143,16 @@ public:
   // Note that this method does not call addRequestGroupIndex(). This
   // method should be considered as private, but exposed for unit
   // testing purpose.
-  void addRequestGroup(const SharedHandle<RequestGroup>& group);
+  void addRequestGroup(const std::shared_ptr<RequestGroup>& group);
 
-  void addReservedGroup(const std::vector<SharedHandle<RequestGroup> >& groups);
+  void addReservedGroup(const std::vector<std::shared_ptr<RequestGroup> >& groups);
 
-  void addReservedGroup(const SharedHandle<RequestGroup>& group);
+  void addReservedGroup(const std::shared_ptr<RequestGroup>& group);
 
   void insertReservedGroup
-  (size_t pos, const std::vector<SharedHandle<RequestGroup> >& groups);
+  (size_t pos, const std::vector<std::shared_ptr<RequestGroup> >& groups);
 
-  void insertReservedGroup(size_t pos, const SharedHandle<RequestGroup>& group);
+  void insertReservedGroup(size_t pos, const std::shared_ptr<RequestGroup>& group);
 
   size_t countRequestGroup() const;
 
@@ -168,7 +168,7 @@ public:
 
   // Returns RequestGroup object whose gid is gid. This method returns
   // RequestGroup either in requestGroups_ or reservedGroups_.
-  SharedHandle<RequestGroup> findGroup(a2_gid_t gid) const;
+  std::shared_ptr<RequestGroup> findGroup(a2_gid_t gid) const;
 
   // Changes the position of download denoted by gid.  If how is
   // POS_SET, it moves the download to a position relative to the
@@ -230,7 +230,7 @@ public:
     return downloadResults_;
   }
 
-  SharedHandle<DownloadResult> findDownloadResult(a2_gid_t gid) const;
+  std::shared_ptr<DownloadResult> findDownloadResult(a2_gid_t gid) const;
 
   // Removes all download results.
   void purgeDownloadResult();
@@ -239,15 +239,15 @@ public:
   // result was removed. Otherwise returns false.
   bool removeDownloadResult(a2_gid_t gid);
 
-  void addDownloadResult(const SharedHandle<DownloadResult>& downloadResult);
+  void addDownloadResult(const std::shared_ptr<DownloadResult>& downloadResult);
 
-  SharedHandle<ServerStat> findServerStat(const std::string& hostname,
+  std::shared_ptr<ServerStat> findServerStat(const std::string& hostname,
                                           const std::string& protocol) const;
 
-  SharedHandle<ServerStat> getOrCreateServerStat(const std::string& hostname,
+  std::shared_ptr<ServerStat> getOrCreateServerStat(const std::string& hostname,
                                                  const std::string& protocol);
 
-  bool addServerStat(const SharedHandle<ServerStat>& serverStat);
+  bool addServerStat(const std::shared_ptr<ServerStat>& serverStat);
 
   bool loadServerStat(const std::string& filename);
 
@@ -311,7 +311,7 @@ public:
   // Returns currently used hosts and its use count.
   void getUsedHosts(std::vector<std::pair<size_t, std::string> >& usedHosts);
 
-  const SharedHandle<ServerStatMan>& getServerStatMan() const
+  const std::shared_ptr<ServerStatMan>& getServerStatMan() const
   {
     return serverStatMan_;
   }
@@ -321,7 +321,7 @@ public:
     maxDownloadResult_ = v;
   }
 
-  void setUriListParser(const SharedHandle<UriListParser>& uriListParser);
+  void setUriListParser(const std::shared_ptr<UriListParser>& uriListParser);
 
   NetStat& getNetStat()
   {
diff --git a/src/RequestSlot.h b/src/RequestSlot.h
index 9ad5e9fe..cb1f073e 100644
--- a/src/RequestSlot.h
+++ b/src/RequestSlot.h
@@ -55,7 +55,7 @@ private:
   // PieceStorage::getPiece() repeatedly. It turns out that this process
   // takes time(about 1.7% of processing time). To reduce it, we put piece here
   // at the construction of RequestSlot as a cache.
-  SharedHandle<Piece> piece_;
+  std::shared_ptr<Piece> piece_;
 
   // inlined for performance reason
   void copy(const RequestSlot& requestSlot)
@@ -70,7 +70,7 @@ private:
 public:
 
   RequestSlot(size_t index, int32_t begin, int32_t length, size_t blockIndex,
-              const SharedHandle<Piece>& piece = SharedHandle<Piece>()):
+              const std::shared_ptr<Piece>& piece = std::shared_ptr<Piece>()):
     dispatchedTime_(global::wallclock()),
     index_(index), begin_(begin), length_(length), blockIndex_(blockIndex),
     piece_(piece) {}
@@ -133,7 +133,7 @@ public:
   size_t getBlockIndex() const { return blockIndex_; }
   void setBlockIndex(size_t blockIndex) { blockIndex_ = blockIndex; }
 
-  const SharedHandle<Piece>& getPiece() const
+  const std::shared_ptr<Piece>& getPiece() const
   {
     return piece_;
   }
diff --git a/src/RpcMethod.cc b/src/RpcMethod.cc
index e61f9926..19467050 100644
--- a/src/RpcMethod.cc
+++ b/src/RpcMethod.cc
@@ -59,10 +59,10 @@ RpcMethod::RpcMethod()
 
 RpcMethod::~RpcMethod() {}
 
-SharedHandle<ValueBase> RpcMethod::createErrorResponse
+std::shared_ptr<ValueBase> RpcMethod::createErrorResponse
 (const Exception& e, const RpcRequest& req)
 {
-  SharedHandle<Dict> params = Dict::g();
+  std::shared_ptr<Dict> params = Dict::g();
   params->put((req.jsonRpc ? "code" : "faultCode"), Integer::g(1));
   params->put((req.jsonRpc ? "message" : "faultString"), std::string(e.what()));
   return params;
@@ -85,7 +85,7 @@ void gatherOption
 (InputIterator first, InputIterator last,
  Pred pred,
  Option* option,
- const SharedHandle<OptionParser>& optionParser)
+ const std::shared_ptr<OptionParser>& optionParser)
 {
   for(; first != last; ++first) {
     const std::string& optionName = (*first).first;
diff --git a/src/RpcMethod.h b/src/RpcMethod.h
index caad0fa4..7f610731 100644
--- a/src/RpcMethod.h
+++ b/src/RpcMethod.h
@@ -38,8 +38,8 @@
 #include "common.h"
 
 #include <string>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "ValueBase.h"
 
 namespace aria2 {
@@ -64,12 +64,12 @@ struct RpcResponse;
 // to RpcMethodFactory.
 class RpcMethod {
 private:
-  SharedHandle<OptionParser> optionParser_;
+  std::shared_ptr<OptionParser> optionParser_;
 protected:
   // Subclass must implement this function to fulfil RpcRequest req.
   // The return value of this method is used as a return value of RPC
   // request.
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e) = 0;
 
   void gatherRequestOption(Option* option, const Dict* optionsDict);
@@ -81,10 +81,10 @@ protected:
 
   void gatherChangeableGlobalOption(Option* option, const Dict* optionDict);
 
-  SharedHandle<ValueBase> createErrorResponse
+  std::shared_ptr<ValueBase> createErrorResponse
   (const Exception& e, const RpcRequest& req);
 
-  const SharedHandle<OptionParser>& getOptionParser() const
+  const std::shared_ptr<OptionParser>& getOptionParser() const
   {
     return optionParser_;
   }
diff --git a/src/RpcMethodFactory.cc b/src/RpcMethodFactory.cc
index 5e73c1a1..3e1d5353 100644
--- a/src/RpcMethodFactory.cc
+++ b/src/RpcMethodFactory.cc
@@ -42,107 +42,107 @@ namespace aria2 {
 namespace rpc {
 
 namespace {
-SharedHandle<RpcMethod> getNoSuchMethod()
+std::shared_ptr<RpcMethod> getNoSuchMethod()
 {
-  static SharedHandle<RpcMethod> m(new NoSuchMethodRpcMethod());
+  static std::shared_ptr<RpcMethod> m(new NoSuchMethodRpcMethod());
   return m;
 }
 } // namespace
 
 namespace {
-SharedHandle<RpcMethod>
+std::shared_ptr<RpcMethod>
 createMethod(const std::string& methodName)
 {
   if(methodName == AddUriRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new AddUriRpcMethod());
+    return std::shared_ptr<RpcMethod>(new AddUriRpcMethod());
 #ifdef ENABLE_BITTORRENT
   } else if(methodName == AddTorrentRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new AddTorrentRpcMethod());
+    return std::shared_ptr<RpcMethod>(new AddTorrentRpcMethod());
 #endif // ENABLE_BITTORRENT
 #ifdef ENABLE_METALINK
   }
   else if(methodName == AddMetalinkRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new AddMetalinkRpcMethod());
+    return std::shared_ptr<RpcMethod>(new AddMetalinkRpcMethod());
 #endif // ENABLE_METALINK
   }
   else if(methodName == RemoveRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new RemoveRpcMethod());
+    return std::shared_ptr<RpcMethod>(new RemoveRpcMethod());
   } else if(methodName == PauseRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new PauseRpcMethod());
+    return std::shared_ptr<RpcMethod>(new PauseRpcMethod());
   } else if(methodName == ForcePauseRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new ForcePauseRpcMethod());
+    return std::shared_ptr<RpcMethod>(new ForcePauseRpcMethod());
   } else if(methodName == PauseAllRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new PauseAllRpcMethod());
+    return std::shared_ptr<RpcMethod>(new PauseAllRpcMethod());
   } else if(methodName == ForcePauseAllRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new ForcePauseAllRpcMethod());
+    return std::shared_ptr<RpcMethod>(new ForcePauseAllRpcMethod());
   } else if(methodName == UnpauseRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new UnpauseRpcMethod());
+    return std::shared_ptr<RpcMethod>(new UnpauseRpcMethod());
   } else if(methodName == UnpauseAllRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new UnpauseAllRpcMethod());
+    return std::shared_ptr<RpcMethod>(new UnpauseAllRpcMethod());
   } else if(methodName == ForceRemoveRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new ForceRemoveRpcMethod());
+    return std::shared_ptr<RpcMethod>(new ForceRemoveRpcMethod());
   } else if(methodName == ChangePositionRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new ChangePositionRpcMethod());
+    return std::shared_ptr<RpcMethod>(new ChangePositionRpcMethod());
   } else if(methodName == TellStatusRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new TellStatusRpcMethod());
+    return std::shared_ptr<RpcMethod>(new TellStatusRpcMethod());
   } else if(methodName == GetUrisRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new GetUrisRpcMethod());
+    return std::shared_ptr<RpcMethod>(new GetUrisRpcMethod());
   } else if(methodName == GetFilesRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new GetFilesRpcMethod());
+    return std::shared_ptr<RpcMethod>(new GetFilesRpcMethod());
 #ifdef ENABLE_BITTORRENT
   }
   else if(methodName == GetPeersRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new GetPeersRpcMethod());
+    return std::shared_ptr<RpcMethod>(new GetPeersRpcMethod());
 #endif // ENABLE_BITTORRENT
   } else if(methodName == GetServersRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new GetServersRpcMethod());
+    return std::shared_ptr<RpcMethod>(new GetServersRpcMethod());
   } else if(methodName == TellActiveRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new TellActiveRpcMethod());
+    return std::shared_ptr<RpcMethod>(new TellActiveRpcMethod());
   } else if(methodName == TellWaitingRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new TellWaitingRpcMethod());
+    return std::shared_ptr<RpcMethod>(new TellWaitingRpcMethod());
   } else if(methodName == TellStoppedRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new TellStoppedRpcMethod());
+    return std::shared_ptr<RpcMethod>(new TellStoppedRpcMethod());
   } else if(methodName == GetOptionRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new GetOptionRpcMethod());
+    return std::shared_ptr<RpcMethod>(new GetOptionRpcMethod());
   } else if(methodName == ChangeUriRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new ChangeUriRpcMethod());
+    return std::shared_ptr<RpcMethod>(new ChangeUriRpcMethod());
   } else if(methodName == ChangeOptionRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new ChangeOptionRpcMethod());
+    return std::shared_ptr<RpcMethod>(new ChangeOptionRpcMethod());
   } else if(methodName == GetGlobalOptionRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new GetGlobalOptionRpcMethod());
+    return std::shared_ptr<RpcMethod>(new GetGlobalOptionRpcMethod());
   } else if(methodName == ChangeGlobalOptionRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new ChangeGlobalOptionRpcMethod());
+    return std::shared_ptr<RpcMethod>(new ChangeGlobalOptionRpcMethod());
   } else if(methodName == PurgeDownloadResultRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new PurgeDownloadResultRpcMethod());
+    return std::shared_ptr<RpcMethod>(new PurgeDownloadResultRpcMethod());
   } else if(methodName == RemoveDownloadResultRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new RemoveDownloadResultRpcMethod());
+    return std::shared_ptr<RpcMethod>(new RemoveDownloadResultRpcMethod());
   } else if(methodName == GetVersionRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new GetVersionRpcMethod());
+    return std::shared_ptr<RpcMethod>(new GetVersionRpcMethod());
   } else if(methodName == GetSessionInfoRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new GetSessionInfoRpcMethod());
+    return std::shared_ptr<RpcMethod>(new GetSessionInfoRpcMethod());
   } else if(methodName == ShutdownRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new ShutdownRpcMethod());
+    return std::shared_ptr<RpcMethod>(new ShutdownRpcMethod());
   } else if(methodName == ForceShutdownRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new ForceShutdownRpcMethod());
+    return std::shared_ptr<RpcMethod>(new ForceShutdownRpcMethod());
   } else if(methodName == GetGlobalStatRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new GetGlobalStatRpcMethod());
+    return std::shared_ptr<RpcMethod>(new GetGlobalStatRpcMethod());
   } else if(methodName == SystemMulticallRpcMethod::getMethodName()) {
-    return SharedHandle<RpcMethod>(new SystemMulticallRpcMethod());
+    return std::shared_ptr<RpcMethod>(new SystemMulticallRpcMethod());
   } else {
-    return SharedHandle<RpcMethod>();
+    return std::shared_ptr<RpcMethod>();
   }
 }
 } // namespace
 
-std::map<std::string, SharedHandle<RpcMethod> > RpcMethodFactory::cache_;
+std::map<std::string, std::shared_ptr<RpcMethod> > RpcMethodFactory::cache_;
 
-SharedHandle<RpcMethod>
+std::shared_ptr<RpcMethod>
 RpcMethodFactory::create(const std::string& methodName)
 {
-  std::map<std::string, SharedHandle<RpcMethod> >::const_iterator itr =
+  std::map<std::string, std::shared_ptr<RpcMethod> >::const_iterator itr =
     cache_.find(methodName);
   if(itr == cache_.end()) {
-    SharedHandle<RpcMethod> m = createMethod(methodName);
+    std::shared_ptr<RpcMethod> m = createMethod(methodName);
     if(m) {
       cache_.insert(std::make_pair(methodName, m));
       return m;
diff --git a/src/RpcMethodFactory.h b/src/RpcMethodFactory.h
index 063502fc..5d479d56 100644
--- a/src/RpcMethodFactory.h
+++ b/src/RpcMethodFactory.h
@@ -39,8 +39,7 @@
 
 #include <string>
 #include <map>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -50,9 +49,9 @@ class RpcMethod;
 
 class RpcMethodFactory {
 public:
-  static SharedHandle<RpcMethod> create(const std::string& methodName);
+  static std::shared_ptr<RpcMethod> create(const std::string& methodName);
 private:
-  static std::map<std::string, SharedHandle<RpcMethod> > cache_;
+  static std::map<std::string, std::shared_ptr<RpcMethod> > cache_;
 };
 
 } // namespace rpc
diff --git a/src/RpcMethodImpl.cc b/src/RpcMethodImpl.cc
index 64174194..4118104e 100644
--- a/src/RpcMethodImpl.cc
+++ b/src/RpcMethodImpl.cc
@@ -83,17 +83,17 @@ namespace aria2 {
 namespace rpc {
 
 namespace {
-const SharedHandle<String> VLB_TRUE = String::g("true");
-const SharedHandle<String> VLB_FALSE = String::g("false");
-const SharedHandle<String> VLB_OK = String::g("OK");
-const SharedHandle<String> VLB_ACTIVE = String::g("active");
-const SharedHandle<String> VLB_WAITING = String::g("waiting");
-const SharedHandle<String> VLB_PAUSED = String::g("paused");
-const SharedHandle<String> VLB_REMOVED = String::g("removed");
-const SharedHandle<String> VLB_ERROR = String::g("error");
-const SharedHandle<String> VLB_COMPLETE = String::g("complete");
-const SharedHandle<String> VLB_USED = String::g("used");
-const SharedHandle<String> VLB_ZERO = String::g("0");
+const std::shared_ptr<String> VLB_TRUE = String::g("true");
+const std::shared_ptr<String> VLB_FALSE = String::g("false");
+const std::shared_ptr<String> VLB_OK = String::g("OK");
+const std::shared_ptr<String> VLB_ACTIVE = String::g("active");
+const std::shared_ptr<String> VLB_WAITING = String::g("waiting");
+const std::shared_ptr<String> VLB_PAUSED = String::g("paused");
+const std::shared_ptr<String> VLB_REMOVED = String::g("removed");
+const std::shared_ptr<String> VLB_ERROR = String::g("error");
+const std::shared_ptr<String> VLB_COMPLETE = String::g("complete");
+const std::shared_ptr<String> VLB_USED = String::g("used");
+const std::shared_ptr<String> VLB_ZERO = String::g("0");
 
 const std::string KEY_GID = "gid";
 const std::string KEY_ERROR_CODE = "errorCode";
@@ -145,15 +145,15 @@ const std::string KEY_NUM_ACTIVE = "numActive";
 } // namespace
 
 namespace {
-SharedHandle<ValueBase> createGIDResponse(a2_gid_t gid)
+std::shared_ptr<ValueBase> createGIDResponse(a2_gid_t gid)
 {
   return String::g(GroupId::toHex(gid));
 }
 } // namespace
 
 namespace {
-SharedHandle<ValueBase>
-addRequestGroup(const SharedHandle<RequestGroup>& group,
+std::shared_ptr<ValueBase>
+addRequestGroup(const std::shared_ptr<RequestGroup>& group,
                 DownloadEngine* e,
                 bool posGiven, int pos)
 {
@@ -216,7 +216,7 @@ void extractUris(OutputIterator out, const List* src)
 }
 } // namespace
 
-SharedHandle<ValueBase> AddUriRpcMethod::process
+std::shared_ptr<ValueBase> AddUriRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const List* urisParam = checkRequiredParam<List>(req, 0);
@@ -229,13 +229,13 @@ SharedHandle<ValueBase> AddUriRpcMethod::process
     throw DL_ABORT_EX("URI is not provided.");
   }
 
-  SharedHandle<Option> requestOption(new Option(*e->getOption()));
+  std::shared_ptr<Option> requestOption(new Option(*e->getOption()));
   gatherRequestOption(requestOption.get(), optsParam);
 
   bool posGiven = checkPosParam(posParam);
   size_t pos = posGiven ? posParam->i() : 0;
 
-  std::vector<SharedHandle<RequestGroup> > result;
+  std::vector<std::shared_ptr<RequestGroup> > result;
   createRequestGroupForUri(result, requestOption, uris,
                            /* ignoreForceSeq = */ true,
                            /* ignoreLocalPath = */ true);
@@ -260,7 +260,7 @@ std::string getHexSha1(const std::string& s)
 #endif // ENABLE_MESSAGE_DIGEST
 
 #ifdef ENABLE_BITTORRENT
-SharedHandle<ValueBase> AddTorrentRpcMethod::process
+std::shared_ptr<ValueBase> AddTorrentRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const String* torrentParam = checkRequiredParam<String>(req, 0);
@@ -268,7 +268,7 @@ SharedHandle<ValueBase> AddTorrentRpcMethod::process
   const Dict* optsParam = checkParam<Dict>(req, 2);
   const Integer* posParam = checkParam<Integer>(req, 3);
 
-  SharedHandle<String> tempTorrentParam;
+  std::shared_ptr<String> tempTorrentParam;
   if(req.jsonRpc) {
     tempTorrentParam = String::g
       (base64::decode(torrentParam->s().begin(),
@@ -278,7 +278,7 @@ SharedHandle<ValueBase> AddTorrentRpcMethod::process
   std::vector<std::string> uris;
   extractUris(std::back_inserter(uris), urisParam);
 
-  SharedHandle<Option> requestOption(new Option(*e->getOption()));
+  std::shared_ptr<Option> requestOption(new Option(*e->getOption()));
   gatherRequestOption(requestOption.get(), optsParam);
 
   bool posGiven = checkPosParam(posParam);
@@ -300,7 +300,7 @@ SharedHandle<ValueBase> AddTorrentRpcMethod::process
       filename.clear();
     }
   }
-  std::vector<SharedHandle<RequestGroup> > result;
+  std::vector<std::shared_ptr<RequestGroup> > result;
   createRequestGroupForBitTorrent(result, requestOption, uris, filename,
                                   torrentParam->s());
 
@@ -313,27 +313,27 @@ SharedHandle<ValueBase> AddTorrentRpcMethod::process
 #endif // ENABLE_BITTORRENT
 
 #ifdef ENABLE_METALINK
-SharedHandle<ValueBase> AddMetalinkRpcMethod::process
+std::shared_ptr<ValueBase> AddMetalinkRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const String* metalinkParam = checkRequiredParam<String>(req, 0);
   const Dict* optsParam = checkParam<Dict>(req, 1);
   const Integer* posParam = checkParam<Integer>(req, 2);
 
-  SharedHandle<String> tempMetalinkParam;
+  std::shared_ptr<String> tempMetalinkParam;
   if(req.jsonRpc) {
     tempMetalinkParam = String::g
       (base64::decode(metalinkParam->s().begin(),
                       metalinkParam->s().end()));
     metalinkParam = tempMetalinkParam.get();
   }
-  SharedHandle<Option> requestOption(new Option(*e->getOption()));
+  std::shared_ptr<Option> requestOption(new Option(*e->getOption()));
   gatherRequestOption(requestOption.get(), optsParam);
 
   bool posGiven = checkPosParam(posParam);
   size_t pos = posGiven ? posParam->i() : 0;
 
-  std::vector<SharedHandle<RequestGroup> > result;
+  std::vector<std::shared_ptr<RequestGroup> > result;
 #ifdef ENABLE_MESSAGE_DIGEST
   std::string filename;
   if(requestOption->getAsBool(PREF_RPC_SAVE_UPLOAD_METADATA)) {
@@ -361,14 +361,14 @@ SharedHandle<ValueBase> AddMetalinkRpcMethod::process
 #else // !ENABLE_MESSAGE_DIGEST
   createRequestGroupForMetalink(result, requestOption, metalinkParam->s());
 #endif // !ENABLE_MESSAGE_DIGEST
-  SharedHandle<List> gids = List::g();
+  std::shared_ptr<List> gids = List::g();
   if(!result.empty()) {
     if(posGiven) {
       e->getRequestGroupMan()->insertReservedGroup(pos, result);
     } else {
       e->getRequestGroupMan()->addReservedGroup(result);
     }
-    for(std::vector<SharedHandle<RequestGroup> >::const_iterator i =
+    for(std::vector<std::shared_ptr<RequestGroup> >::const_iterator i =
           result.begin(), eoi = result.end(); i != eoi; ++i) {
       gids->append(GroupId::toHex((*i)->getGID()));
     }
@@ -378,13 +378,13 @@ SharedHandle<ValueBase> AddMetalinkRpcMethod::process
 #endif // ENABLE_METALINK
 
 namespace {
-SharedHandle<ValueBase> removeDownload
+std::shared_ptr<ValueBase> removeDownload
 (const RpcRequest& req, DownloadEngine* e, bool forceRemove)
 {
   const String* gidParam = checkRequiredParam<String>(req, 0);
 
   a2_gid_t gid = str2Gid(gidParam);
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
   if(group) {
     if(group->getState() == RequestGroup::STATE_ACTIVE) {
       if(forceRemove) {
@@ -409,26 +409,26 @@ SharedHandle<ValueBase> removeDownload
 }
 } // namespace
 
-SharedHandle<ValueBase> RemoveRpcMethod::process
+std::shared_ptr<ValueBase> RemoveRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   return removeDownload(req, e, false);
 }
 
-SharedHandle<ValueBase> ForceRemoveRpcMethod::process
+std::shared_ptr<ValueBase> ForceRemoveRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   return removeDownload(req, e, true);
 }
 
 namespace {
-SharedHandle<ValueBase> pauseDownload
+std::shared_ptr<ValueBase> pauseDownload
 (const RpcRequest& req, DownloadEngine* e, bool forcePause)
 {
   const String* gidParam = checkRequiredParam<String>(req, 0);
 
   a2_gid_t gid = str2Gid(gidParam);
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
   if(group) {
     bool reserved = group->getState() == RequestGroup::STATE_WAITING;
     if(pauseRequestGroup(group, reserved, forcePause)) {
@@ -441,13 +441,13 @@ SharedHandle<ValueBase> pauseDownload
 }
 } // namespace
 
-SharedHandle<ValueBase> PauseRpcMethod::process
+std::shared_ptr<ValueBase> PauseRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   return pauseDownload(req, e, false);
 }
 
-SharedHandle<ValueBase> ForcePauseRpcMethod::process
+std::shared_ptr<ValueBase> ForcePauseRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   return pauseDownload(req, e, true);
@@ -465,7 +465,7 @@ void pauseRequestGroups
 } // namespace
 
 namespace {
-SharedHandle<ValueBase> pauseAllDownloads
+std::shared_ptr<ValueBase> pauseAllDownloads
 (const RpcRequest& req, DownloadEngine* e, bool forcePause)
 {
   const RequestGroupList& groups = e->getRequestGroupMan()->getRequestGroups();
@@ -478,25 +478,25 @@ SharedHandle<ValueBase> pauseAllDownloads
 }
 } // namespace
 
-SharedHandle<ValueBase> PauseAllRpcMethod::process
+std::shared_ptr<ValueBase> PauseAllRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   return pauseAllDownloads(req, e, false);
 }
 
-SharedHandle<ValueBase> ForcePauseAllRpcMethod::process
+std::shared_ptr<ValueBase> ForcePauseAllRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   return pauseAllDownloads(req, e, true);
 }
 
-SharedHandle<ValueBase> UnpauseRpcMethod::process
+std::shared_ptr<ValueBase> UnpauseRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const String* gidParam = checkRequiredParam<String>(req, 0);
 
   a2_gid_t gid = str2Gid(gidParam);
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
   if(!group ||
      group->getState() != RequestGroup::STATE_WAITING ||
      !group->isPauseRequested()) {
@@ -509,7 +509,7 @@ SharedHandle<ValueBase> UnpauseRpcMethod::process
   return createGIDResponse(gid);
 }
 
-SharedHandle<ValueBase> UnpauseAllRpcMethod::process
+std::shared_ptr<ValueBase> UnpauseAllRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const RequestGroupList& groups =
@@ -525,12 +525,12 @@ SharedHandle<ValueBase> UnpauseAllRpcMethod::process
 namespace {
 template<typename InputIterator>
 void createUriEntry
-(const SharedHandle<List>& uriList,
+(const std::shared_ptr<List>& uriList,
  InputIterator first, InputIterator last,
- const SharedHandle<String>& status)
+ const std::shared_ptr<String>& status)
 {
   for(; first != last; ++first) {
-    SharedHandle<Dict> entry = Dict::g();
+    std::shared_ptr<Dict> entry = Dict::g();
     entry->put(KEY_URI, *first);
     entry->put(KEY_STATUS, status);
     uriList->append(entry);
@@ -540,7 +540,7 @@ void createUriEntry
 
 namespace {
 void createUriEntry
-(const SharedHandle<List>& uriList, const SharedHandle<FileEntry>& file)
+(const std::shared_ptr<List>& uriList, const std::shared_ptr<FileEntry>& file)
 {
   createUriEntry(uriList,
                  file->getSpentUris().begin(),
@@ -556,13 +556,13 @@ void createUriEntry
 namespace {
 template<typename InputIterator>
 void createFileEntry
-(const SharedHandle<List>& files,
+(const std::shared_ptr<List>& files,
  InputIterator first, InputIterator last,
  const BitfieldMan* bf)
 {
   size_t index = 1;
   for(; first != last; ++first, ++index) {
-    SharedHandle<Dict> entry = Dict::g();
+    std::shared_ptr<Dict> entry = Dict::g();
     entry->put(KEY_INDEX, util::uitos(index));
     entry->put(KEY_PATH, (*first)->getPath());
     entry->put(KEY_SELECTED, (*first)->isRequested()?VLB_TRUE:VLB_FALSE);
@@ -571,7 +571,7 @@ void createFileEntry
       ((*first)->getOffset(), (*first)->getLength());
     entry->put(KEY_COMPLETED_LENGTH, util::itos(completedLength));
 
-    SharedHandle<List> uriList = List::g();
+    std::shared_ptr<List> uriList = List::g();
     createUriEntry(uriList, *first);
     entry->put(KEY_URIS, uriList);
     files->append(entry);
@@ -582,7 +582,7 @@ void createFileEntry
 namespace {
 template<typename InputIterator>
 void createFileEntry
-(const SharedHandle<List>& files,
+(const std::shared_ptr<List>& files,
  InputIterator first, InputIterator last,
  int64_t totalLength,
  int32_t pieceLength,
@@ -598,11 +598,11 @@ void createFileEntry
 namespace {
 template<typename InputIterator>
 void createFileEntry
-(const SharedHandle<List>& files,
+(const std::shared_ptr<List>& files,
  InputIterator first, InputIterator last,
  int64_t totalLength,
  int32_t pieceLength,
- const SharedHandle<PieceStorage>& ps)
+ const std::shared_ptr<PieceStorage>& ps)
 {
   BitfieldMan bf(pieceLength, totalLength);
   if(ps) {
@@ -621,11 +621,11 @@ bool requested_key
 } // namespace
 
 void gatherProgressCommon
-(const SharedHandle<Dict>& entryDict,
- const SharedHandle<RequestGroup>& group,
+(const std::shared_ptr<Dict>& entryDict,
+ const std::shared_ptr<RequestGroup>& group,
  const std::vector<std::string>& keys)
 {
-  const SharedHandle<PieceStorage>& ps = group->getPieceStorage();
+  const std::shared_ptr<PieceStorage>& ps = group->getPieceStorage();
   if(requested_key(keys, KEY_GID)) {
     entryDict->put(KEY_GID, GroupId::toHex(group->getGID()).c_str());
   }
@@ -660,7 +660,7 @@ void gatherProgressCommon
       }
     }
   }
-  const SharedHandle<DownloadContext>& dctx = group->getDownloadContext();
+  const std::shared_ptr<DownloadContext>& dctx = group->getDownloadContext();
   if(requested_key(keys, KEY_PIECE_LENGTH)) {
     entryDict->put(KEY_PIECE_LENGTH, util::itos(dctx->getPieceLength()));
   }
@@ -669,7 +669,7 @@ void gatherProgressCommon
   }
   if(requested_key(keys, KEY_FOLLOWED_BY)) {
     if(!group->followedBy().empty()) {
-      SharedHandle<List> list = List::g();
+      std::shared_ptr<List> list = List::g();
       // The element is GID.
       for(std::vector<a2_gid_t>::const_iterator i = group->followedBy().begin(),
             eoi = group->followedBy().end(); i != eoi; ++i) {
@@ -684,7 +684,7 @@ void gatherProgressCommon
     }
   }
   if(requested_key(keys, KEY_FILES)) {
-    SharedHandle<List> files = List::g();
+    std::shared_ptr<List> files = List::g();
     createFileEntry
       (files, dctx->getFileEntries().begin(), dctx->getFileEntries().end(),
        dctx->getTotalLength(), dctx->getPieceLength(), ps);
@@ -697,8 +697,8 @@ void gatherProgressCommon
 
 #ifdef ENABLE_BITTORRENT
 void gatherBitTorrentMetadata
-(const SharedHandle<Dict>& btDict,
- const SharedHandle<TorrentAttribute>& torrentAttrs)
+(const std::shared_ptr<Dict>& btDict,
+ const std::shared_ptr<TorrentAttribute>& torrentAttrs)
 {
   if(!torrentAttrs->comment.empty()) {
     btDict->put(KEY_COMMENT, torrentAttrs->comment);
@@ -709,11 +709,11 @@ void gatherBitTorrentMetadata
   if(torrentAttrs->mode) {
     btDict->put(KEY_MODE, bittorrent::getModeString(torrentAttrs->mode));
   }
-  SharedHandle<List> destAnnounceList = List::g();
+  std::shared_ptr<List> destAnnounceList = List::g();
   for(std::vector<std::vector<std::string> >::const_iterator l =
         torrentAttrs->announceList.begin(),
         eoi = torrentAttrs->announceList.end(); l != eoi; ++l) {
-    SharedHandle<List> destAnnounceTier = List::g();
+    std::shared_ptr<List> destAnnounceTier = List::g();
     for(std::vector<std::string>::const_iterator t = (*l).begin(),
           eoi2 = (*l).end(); t != eoi2; ++t) {
       destAnnounceTier->append(*t);
@@ -722,7 +722,7 @@ void gatherBitTorrentMetadata
   }
   btDict->put(KEY_ANNOUNCE_LIST, destAnnounceList);
   if(!torrentAttrs->metadata.empty()) {
-    SharedHandle<Dict> infoDict = Dict::g();
+    std::shared_ptr<Dict> infoDict = Dict::g();
     infoDict->put(KEY_NAME, torrentAttrs->name);
     btDict->put(KEY_INFO, infoDict);
   }
@@ -730,16 +730,16 @@ void gatherBitTorrentMetadata
 
 namespace {
 void gatherProgressBitTorrent
-(const SharedHandle<Dict>& entryDict,
- const SharedHandle<TorrentAttribute>& torrentAttrs,
- const SharedHandle<BtObject>& btObject,
+(const std::shared_ptr<Dict>& entryDict,
+ const std::shared_ptr<TorrentAttribute>& torrentAttrs,
+ const std::shared_ptr<BtObject>& btObject,
  const std::vector<std::string>& keys)
 {
   if(requested_key(keys, KEY_INFO_HASH)) {
     entryDict->put(KEY_INFO_HASH, util::toHex(torrentAttrs->infoHash));
   }
   if(requested_key(keys, KEY_BITTORRENT)) {
-    SharedHandle<Dict> btDict = Dict::g();
+    std::shared_ptr<Dict> btDict = Dict::g();
     gatherBitTorrentMetadata(btDict, torrentAttrs);
     entryDict->put(KEY_BITTORRENT, btDict);
   }
@@ -747,7 +747,7 @@ void gatherProgressBitTorrent
     if(!btObject) {
       entryDict->put(KEY_NUM_SEEDERS, VLB_ZERO);
     } else {
-      const SharedHandle<PeerStorage>& peerStorage = btObject->peerStorage;
+      const std::shared_ptr<PeerStorage>& peerStorage = btObject->peerStorage;
       assert(peerStorage);
       const PeerSet& peers = peerStorage->getUsedPeers();
       entryDict->put(KEY_NUM_SEEDERS,
@@ -759,7 +759,7 @@ void gatherProgressBitTorrent
 
 namespace {
 void gatherPeer
-(const SharedHandle<List>& peers, const SharedHandle<PeerStorage>& ps)
+(const std::shared_ptr<List>& peers, const std::shared_ptr<PeerStorage>& ps)
 {
   const PeerSet& usedPeers = ps->getUsedPeers();
   for(PeerSet::const_iterator i = usedPeers.begin(), eoi = usedPeers.end();
@@ -767,7 +767,7 @@ void gatherPeer
     if(!(*i)->isActive()) {
       continue;
     }
-    SharedHandle<Dict> peerEntry = Dict::g();
+    std::shared_ptr<Dict> peerEntry = Dict::g();
     peerEntry->put(KEY_PEER_ID, util::torrentPercentEncode((*i)->getPeerId(),
                                                            PEER_ID_LENGTH));
     peerEntry->put(KEY_IP, (*i)->getIPAddress());
@@ -793,17 +793,17 @@ void gatherPeer
 
 namespace {
 void gatherProgress
-(const SharedHandle<Dict>& entryDict,
- const SharedHandle<RequestGroup>& group,
+(const std::shared_ptr<Dict>& entryDict,
+ const std::shared_ptr<RequestGroup>& group,
  DownloadEngine* e,
  const std::vector<std::string>& keys)
 {
   gatherProgressCommon(entryDict, group, keys);
 #ifdef ENABLE_BITTORRENT
   if(group->getDownloadContext()->hasAttribute(CTX_ATTR_BT)) {
-    SharedHandle<TorrentAttribute> torrentAttrs =
+    std::shared_ptr<TorrentAttribute> torrentAttrs =
       bittorrent::getTorrentAttrs(group->getDownloadContext());
-    const SharedHandle<BtObject>& btObject =
+    const std::shared_ptr<BtObject>& btObject =
       e->getBtRegistry()->get(group->getGID());
     gatherProgressBitTorrent(entryDict, torrentAttrs, btObject, keys);
   }
@@ -812,7 +812,7 @@ void gatherProgress
 } // namespace
 
 void gatherStoppedDownload
-(const SharedHandle<Dict>& entryDict, const SharedHandle<DownloadResult>& ds,
+(const std::shared_ptr<Dict>& entryDict, const std::shared_ptr<DownloadResult>& ds,
  const std::vector<std::string>& keys)
 {
   if(requested_key(keys, KEY_GID)) {
@@ -832,7 +832,7 @@ void gatherStoppedDownload
   }
   if(requested_key(keys, KEY_FOLLOWED_BY)) {
     if(!ds->followedBy.empty()) {
-      SharedHandle<List> list = List::g();
+      std::shared_ptr<List> list = List::g();
       // The element is GID.
       for(std::vector<a2_gid_t>::const_iterator i = ds->followedBy.begin(),
             eoi = ds->followedBy.end(); i != eoi; ++i) {
@@ -847,7 +847,7 @@ void gatherStoppedDownload
     }
   }
   if(requested_key(keys, KEY_FILES)) {
-    SharedHandle<List> files = List::g();
+    std::shared_ptr<List> files = List::g();
     createFileEntry(files, ds->fileEntries.begin(), ds->fileEntries.end(),
                     ds->totalLength, ds->pieceLength, ds->bitfield);
     entryDict->put(KEY_FILES, files);
@@ -894,16 +894,16 @@ void gatherStoppedDownload
   }
 }
 
-SharedHandle<ValueBase> GetFilesRpcMethod::process
+std::shared_ptr<ValueBase> GetFilesRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const String* gidParam = checkRequiredParam<String>(req, 0);
 
   a2_gid_t gid = str2Gid(gidParam);
-  SharedHandle<List> files = List::g();
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<List> files = List::g();
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
   if(!group) {
-    SharedHandle<DownloadResult> dr =
+    std::shared_ptr<DownloadResult> dr =
       e->getRequestGroupMan()->findDownloadResult(gid);
     if(!dr) {
       throw DL_ABORT_EX(fmt("No file data is available for GID#%s",
@@ -913,8 +913,8 @@ SharedHandle<ValueBase> GetFilesRpcMethod::process
                       dr->totalLength, dr->pieceLength, dr->bitfield);
     }
   } else {
-    const SharedHandle<PieceStorage>& ps = group->getPieceStorage();
-    const SharedHandle<DownloadContext>& dctx = group->getDownloadContext();
+    const std::shared_ptr<PieceStorage>& ps = group->getPieceStorage();
+    const std::shared_ptr<DownloadContext>& dctx = group->getDownloadContext();
     createFileEntry(files,
                     group->getDownloadContext()->getFileEntries().begin(),
                     group->getDownloadContext()->getFileEntries().end(),
@@ -925,18 +925,18 @@ SharedHandle<ValueBase> GetFilesRpcMethod::process
   return files;
 }
 
-SharedHandle<ValueBase> GetUrisRpcMethod::process
+std::shared_ptr<ValueBase> GetUrisRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const String* gidParam = checkRequiredParam<String>(req, 0);
 
   a2_gid_t gid = str2Gid(gidParam);
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
   if(!group) {
     throw DL_ABORT_EX(fmt("No URI data is available for GID#%s",
                           GroupId::toHex(gid).c_str()));
   }
-  SharedHandle<List> uriList = List::g();
+  std::shared_ptr<List> uriList = List::g();
   // TODO Current implementation just returns first FileEntry's URIs.
   if(!group->getDownloadContext()->getFileEntries().empty()) {
     createUriEntry(uriList, group->getDownloadContext()->getFirstFileEntry());
@@ -945,19 +945,19 @@ SharedHandle<ValueBase> GetUrisRpcMethod::process
 }
 
 #ifdef ENABLE_BITTORRENT
-SharedHandle<ValueBase> GetPeersRpcMethod::process
+std::shared_ptr<ValueBase> GetPeersRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const String* gidParam = checkRequiredParam<String>(req, 0);
 
   a2_gid_t gid = str2Gid(gidParam);
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
   if(!group) {
     throw DL_ABORT_EX(fmt("No peer data is available for GID#%s",
                           GroupId::toHex(gid).c_str()));
   }
-  SharedHandle<List> peers = List::g();
-  const SharedHandle<BtObject>& btObject =
+  std::shared_ptr<List> peers = List::g();
+  const std::shared_ptr<BtObject>& btObject =
     e->getBtRegistry()->get(group->getGID());
   if(btObject) {
     assert(btObject->peerStorage);
@@ -967,7 +967,7 @@ SharedHandle<ValueBase> GetPeersRpcMethod::process
 }
 #endif // ENABLE_BITTORRENT
 
-SharedHandle<ValueBase> TellStatusRpcMethod::process
+std::shared_ptr<ValueBase> TellStatusRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const String* gidParam = checkRequiredParam<String>(req, 0);
@@ -977,11 +977,11 @@ SharedHandle<ValueBase> TellStatusRpcMethod::process
   std::vector<std::string> keys;
   toStringList(std::back_inserter(keys), keysParam);
 
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
 
-  SharedHandle<Dict> entryDict = Dict::g();
+  std::shared_ptr<Dict> entryDict = Dict::g();
   if(!group) {
-    SharedHandle<DownloadResult> ds =
+    std::shared_ptr<DownloadResult> ds =
       e->getRequestGroupMan()->findDownloadResult(gid);
     if(!ds) {
       throw DL_ABORT_EX(fmt("No such download for GID#%s",
@@ -1005,17 +1005,17 @@ SharedHandle<ValueBase> TellStatusRpcMethod::process
   return entryDict;
 }
 
-SharedHandle<ValueBase> TellActiveRpcMethod::process
+std::shared_ptr<ValueBase> TellActiveRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const List* keysParam = checkParam<List>(req, 0);
   std::vector<std::string> keys;
   toStringList(std::back_inserter(keys), keysParam);
-  SharedHandle<List> list = List::g();
+  std::shared_ptr<List> list = List::g();
   const RequestGroupList& groups = e->getRequestGroupMan()->getRequestGroups();
   for(RequestGroupList::const_iterator i = groups.begin(),
         eoi = groups.end(); i != eoi; ++i) {
-    SharedHandle<Dict> entryDict = Dict::g();
+    std::shared_ptr<Dict> entryDict = Dict::g();
     if(requested_key(keys, KEY_STATUS)) {
       entryDict->put(KEY_STATUS, VLB_ACTIVE);
     }
@@ -1032,8 +1032,8 @@ TellWaitingRpcMethod::getItems(DownloadEngine* e) const
 }
 
 void TellWaitingRpcMethod::createEntry
-(const SharedHandle<Dict>& entryDict,
- const SharedHandle<RequestGroup>& item,
+(const std::shared_ptr<Dict>& entryDict,
+ const std::shared_ptr<RequestGroup>& item,
  DownloadEngine* e,
  const std::vector<std::string>& keys) const
 {
@@ -1054,22 +1054,22 @@ TellStoppedRpcMethod::getItems(DownloadEngine* e) const
 }
 
 void TellStoppedRpcMethod::createEntry
-(const SharedHandle<Dict>& entryDict,
- const SharedHandle<DownloadResult>& item,
+(const std::shared_ptr<Dict>& entryDict,
+ const std::shared_ptr<DownloadResult>& item,
  DownloadEngine* e,
  const std::vector<std::string>& keys) const
 {
   gatherStoppedDownload(entryDict, item, keys);
 }
 
-SharedHandle<ValueBase> PurgeDownloadResultRpcMethod::process
+std::shared_ptr<ValueBase> PurgeDownloadResultRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   e->getRequestGroupMan()->purgeDownloadResult();
   return VLB_OK;
 }
 
-SharedHandle<ValueBase> RemoveDownloadResultRpcMethod::process
+std::shared_ptr<ValueBase> RemoveDownloadResultRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const String* gidParam = checkRequiredParam<String>(req, 0);
@@ -1082,14 +1082,14 @@ SharedHandle<ValueBase> RemoveDownloadResultRpcMethod::process
   return VLB_OK;
 }
 
-SharedHandle<ValueBase> ChangeOptionRpcMethod::process
+std::shared_ptr<ValueBase> ChangeOptionRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const String* gidParam = checkRequiredParam<String>(req, 0);
   const Dict* optsParam = checkRequiredParam<Dict>(req, 1);
 
   a2_gid_t gid = str2Gid(gidParam);
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
   Option option;
   if(group) {
     if(group->getState() == RequestGroup::STATE_ACTIVE) {
@@ -1105,7 +1105,7 @@ SharedHandle<ValueBase> ChangeOptionRpcMethod::process
   return VLB_OK;
 }
 
-SharedHandle<ValueBase> ChangeGlobalOptionRpcMethod::process
+std::shared_ptr<ValueBase> ChangeGlobalOptionRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const Dict* optsParam = checkRequiredParam<Dict>(req, 0);
@@ -1116,12 +1116,12 @@ SharedHandle<ValueBase> ChangeGlobalOptionRpcMethod::process
   return VLB_OK;
 }
 
-SharedHandle<ValueBase> GetVersionRpcMethod::process
+std::shared_ptr<ValueBase> GetVersionRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
-  SharedHandle<Dict> result = Dict::g();
+  std::shared_ptr<Dict> result = Dict::g();
   result->put(KEY_VERSION, PACKAGE_VERSION);
-  SharedHandle<List> featureList = List::g();
+  std::shared_ptr<List> featureList = List::g();
   for(int feat = 0; feat < MAX_FEATURE; ++feat) {
     const char* name = strSupportedFeature(feat);
     if(name) {
@@ -1134,9 +1134,9 @@ SharedHandle<ValueBase> GetVersionRpcMethod::process
 
 namespace {
 void pushRequestOption
-(const SharedHandle<Dict>& dict,
- const SharedHandle<Option>& option,
- const SharedHandle<OptionParser>& oparser)
+(const std::shared_ptr<Dict>& dict,
+ const std::shared_ptr<Option>& option,
+ const std::shared_ptr<OptionParser>& oparser)
 {
   for(size_t i = 1, len = option::countOption(); i < len; ++i) {
     const Pref* pref = option::i2p(i);
@@ -1148,16 +1148,16 @@ void pushRequestOption
 }
 } // namespace
 
-SharedHandle<ValueBase> GetOptionRpcMethod::process
+std::shared_ptr<ValueBase> GetOptionRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const String* gidParam = checkRequiredParam<String>(req, 0);
 
   a2_gid_t gid = str2Gid(gidParam);
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
-  SharedHandle<Dict> result = Dict::g();
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<Dict> result = Dict::g();
   if(!group) {
-    SharedHandle<DownloadResult> dr =
+    std::shared_ptr<DownloadResult> dr =
       e->getRequestGroupMan()->findDownloadResult(gid);
     if(!dr) {
       throw DL_ABORT_EX(fmt("Cannot get option for GID#%s",
@@ -1170,10 +1170,10 @@ SharedHandle<ValueBase> GetOptionRpcMethod::process
   return result;
 }
 
-SharedHandle<ValueBase> GetGlobalOptionRpcMethod::process
+std::shared_ptr<ValueBase> GetGlobalOptionRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
-  SharedHandle<Dict> result = Dict::g();
+  std::shared_ptr<Dict> result = Dict::g();
   for(size_t i = 0, len = e->getOption()->getTable().size(); i < len; ++i) {
     const Pref* pref = option::i2p(i);
     if(!e->getOption()->defined(pref)) {
@@ -1187,7 +1187,7 @@ SharedHandle<ValueBase> GetGlobalOptionRpcMethod::process
   return result;
 }
 
-SharedHandle<ValueBase> ChangePositionRpcMethod::process
+std::shared_ptr<ValueBase> ChangePositionRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const String* gidParam = checkRequiredParam<String>(req, 0);
@@ -1209,45 +1209,45 @@ SharedHandle<ValueBase> ChangePositionRpcMethod::process
   }
   size_t destPos =
     e->getRequestGroupMan()->changeReservedGroupPosition(gid, pos, how);
-  SharedHandle<Integer> result = Integer::g(destPos);
+  std::shared_ptr<Integer> result = Integer::g(destPos);
   return result;
 }
 
-SharedHandle<ValueBase> GetSessionInfoRpcMethod::process
+std::shared_ptr<ValueBase> GetSessionInfoRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
-  SharedHandle<Dict> result = Dict::g();
+  std::shared_ptr<Dict> result = Dict::g();
   result->put(KEY_SESSION_ID, util::toHex(e->getSessionId()));
   return result;
 }
 
-SharedHandle<ValueBase> GetServersRpcMethod::process
+std::shared_ptr<ValueBase> GetServersRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const String* gidParam = checkRequiredParam<String>(req, 0);
 
   a2_gid_t gid = str2Gid(gidParam);
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
   if(!group || group->getState() != RequestGroup::STATE_ACTIVE) {
     throw DL_ABORT_EX(fmt("No active download for GID#%s",
                           GroupId::toHex(gid).c_str()));
   }
-  const SharedHandle<DownloadContext>& dctx = group->getDownloadContext();
-  const std::vector<SharedHandle<FileEntry> >& files = dctx->getFileEntries();
-  SharedHandle<List> result = List::g();
+  const std::shared_ptr<DownloadContext>& dctx = group->getDownloadContext();
+  const std::vector<std::shared_ptr<FileEntry> >& files = dctx->getFileEntries();
+  std::shared_ptr<List> result = List::g();
   size_t index = 1;
-  for(std::vector<SharedHandle<FileEntry> >::const_iterator fi = files.begin(),
+  for(std::vector<std::shared_ptr<FileEntry> >::const_iterator fi = files.begin(),
         eoi = files.end(); fi != eoi; ++fi, ++index) {
-    SharedHandle<Dict> fileEntry = Dict::g();
+    std::shared_ptr<Dict> fileEntry = Dict::g();
     fileEntry->put(KEY_INDEX, util::uitos(index));
-    SharedHandle<List> servers = List::g();
+    std::shared_ptr<List> servers = List::g();
     const FileEntry::InFlightRequestSet& requests =
       (*fi)->getInFlightRequests();
     for(FileEntry::InFlightRequestSet::iterator ri =requests.begin(),
           eoi = requests.end(); ri != eoi; ++ri) {
-      SharedHandle<PeerStat> ps = (*ri)->getPeerStat();
+      std::shared_ptr<PeerStat> ps = (*ri)->getPeerStat();
       if(ps) {
-        SharedHandle<Dict> serverEntry = Dict::g();
+        std::shared_ptr<Dict> serverEntry = Dict::g();
         serverEntry->put(KEY_URI, (*ri)->getUri());
         serverEntry->put(KEY_CURRENT_URI, (*ri)->getCurrentUri());
         serverEntry->put(KEY_DOWNLOAD_SPEED,
@@ -1261,7 +1261,7 @@ SharedHandle<ValueBase> GetServersRpcMethod::process
   return result;
 }
 
-SharedHandle<ValueBase> ChangeUriRpcMethod::process
+std::shared_ptr<ValueBase> ChangeUriRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const String* gidParam = checkRequiredParam<String>(req, 0);
@@ -1274,17 +1274,17 @@ SharedHandle<ValueBase> ChangeUriRpcMethod::process
   bool posGiven = checkPosParam(posParam);
   size_t pos = posGiven ? posParam->i() : 0;
   size_t index = indexParam->i()-1;
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
   if(!group) {
     throw DL_ABORT_EX(fmt("Cannot remove URIs from GID#%s",
                           GroupId::toHex(gid).c_str()));
   }
-  const SharedHandle<DownloadContext>& dctx = group->getDownloadContext();
-  const std::vector<SharedHandle<FileEntry> >& files = dctx->getFileEntries();
+  const std::shared_ptr<DownloadContext>& dctx = group->getDownloadContext();
+  const std::vector<std::shared_ptr<FileEntry> >& files = dctx->getFileEntries();
   if(files.size() <= index) {
     throw DL_ABORT_EX(fmt("fileIndex is out of range"));
   }
-  SharedHandle<FileEntry> s = files[index];
+  std::shared_ptr<FileEntry> s = files[index];
   size_t delcount = 0;
   for(List::ValueType::const_iterator i = delUrisParam->begin(),
         eoi = delUrisParam->end(); i != eoi; ++i) {
@@ -1318,14 +1318,14 @@ SharedHandle<ValueBase> ChangeUriRpcMethod::process
     e->addCommand(commands);
     group->getSegmentMan()->recognizeSegmentFor(s);
   }
-  SharedHandle<List> res = List::g();
+  std::shared_ptr<List> res = List::g();
   res->append(Integer::g(delcount));
   res->append(Integer::g(addcount));
   return res;
 }
 
 namespace {
-SharedHandle<ValueBase> goingShutdown
+std::shared_ptr<ValueBase> goingShutdown
 (const RpcRequest& req, DownloadEngine* e, bool forceHalt)
 {
   // Schedule shutdown after 3seconds to give time to client to
@@ -1336,24 +1336,24 @@ SharedHandle<ValueBase> goingShutdown
 }
 } // namespace
 
-SharedHandle<ValueBase> ShutdownRpcMethod::process
+std::shared_ptr<ValueBase> ShutdownRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   return goingShutdown(req, e, false);
 }
 
-SharedHandle<ValueBase> ForceShutdownRpcMethod::process
+std::shared_ptr<ValueBase> ForceShutdownRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   return goingShutdown(req, e, true);
 }
 
-SharedHandle<ValueBase> GetGlobalStatRpcMethod::process
+std::shared_ptr<ValueBase> GetGlobalStatRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
-  const SharedHandle<RequestGroupMan>& rgman = e->getRequestGroupMan();
+  const std::shared_ptr<RequestGroupMan>& rgman = e->getRequestGroupMan();
   TransferStat ts = rgman->calculateStat();
-  SharedHandle<Dict> res = Dict::g();
+  std::shared_ptr<Dict> res = Dict::g();
   res->put(KEY_DOWNLOAD_SPEED, util::itos(ts.downloadSpeed));
   res->put(KEY_UPLOAD_SPEED, util::itos(ts.uploadSpeed));
   res->put(KEY_NUM_WAITING, util::uitos(rgman->getReservedGroups().size()));
@@ -1362,11 +1362,11 @@ SharedHandle<ValueBase> GetGlobalStatRpcMethod::process
   return res;
 }
 
-SharedHandle<ValueBase> SystemMulticallRpcMethod::process
+std::shared_ptr<ValueBase> SystemMulticallRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   const List* methodSpecs = checkRequiredParam<List>(req, 0);
-  SharedHandle<List> list = List::g();
+  std::shared_ptr<List> list = List::g();
   for(List::ValueType::const_iterator i = methodSpecs->begin(),
         eoi = methodSpecs->end(); i != eoi; ++i) {
     const Dict* methodDict = downcast<Dict>(*i);
@@ -1386,19 +1386,19 @@ SharedHandle<ValueBase> SystemMulticallRpcMethod::process
                    (DL_ABORT_EX("Recursive system.multicall forbidden."), req));
       continue;
     }
-    const SharedHandle<ValueBase>& tempParamsList = methodDict->get(KEY_PARAMS);
-    SharedHandle<List> paramsList;
+    const std::shared_ptr<ValueBase>& tempParamsList = methodDict->get(KEY_PARAMS);
+    std::shared_ptr<List> paramsList;
     if(downcast<List>(tempParamsList)) {
-      paramsList = static_pointer_cast<List>(tempParamsList);
+      paramsList = std::static_pointer_cast<List>(tempParamsList);
     } else {
       paramsList = List::g();
     }
-    SharedHandle<RpcMethod> method = RpcMethodFactory::create(methodName->s());
+    std::shared_ptr<RpcMethod> method = RpcMethodFactory::create(methodName->s());
     RpcRequest innerReq(methodName->s(), paramsList);
     innerReq.jsonRpc = req.jsonRpc;
     RpcResponse res = method->execute(innerReq, e);
     if(res.code == 0) {
-      SharedHandle<List> l = List::g();
+      std::shared_ptr<List> l = List::g();
       l->append(res.param);
       list->append(l);
     } else {
@@ -1408,7 +1408,7 @@ SharedHandle<ValueBase> SystemMulticallRpcMethod::process
   return list;
 }
 
-SharedHandle<ValueBase> NoSuchMethodRpcMethod::process
+std::shared_ptr<ValueBase> NoSuchMethodRpcMethod::process
 (const RpcRequest& req, DownloadEngine* e)
 {
   throw DL_ABORT_EX(fmt("No such method: %s", req.methodName.c_str()));
@@ -1417,7 +1417,7 @@ SharedHandle<ValueBase> NoSuchMethodRpcMethod::process
 } // namespace rpc
 
 bool pauseRequestGroup
-(const SharedHandle<RequestGroup>& group, bool reserved,  bool forcePause)
+(const std::shared_ptr<RequestGroup>& group, bool reserved,  bool forcePause)
 {
   if((reserved && !group->isPauseRequested()) ||
      (!reserved &&
@@ -1441,12 +1441,12 @@ bool pauseRequestGroup
 }
 
 void changeOption
-(const SharedHandle<RequestGroup>& group,
+(const std::shared_ptr<RequestGroup>& group,
  const Option& option,
  DownloadEngine* e)
 {
-  const SharedHandle<DownloadContext>& dctx = group->getDownloadContext();
-  const SharedHandle<Option>& grOption = group->getOption();
+  const std::shared_ptr<DownloadContext>& dctx = group->getDownloadContext();
+  const std::shared_ptr<Option>& grOption = group->getOption();
   grOption->merge(option);
   if(option.defined(PREF_CHECKSUM)) {
     const std::string& checksum = grOption->get(PREF_CHECKSUM);
@@ -1467,8 +1467,8 @@ void changeOption
   }
   if(option.defined(PREF_MAX_CONNECTION_PER_SERVER)) {
     int maxConn = grOption->getAsInt(PREF_MAX_CONNECTION_PER_SERVER);
-    const std::vector<SharedHandle<FileEntry> >& files = dctx->getFileEntries();
-    for(std::vector<SharedHandle<FileEntry> >::const_iterator i = files.begin(),
+    const std::vector<std::shared_ptr<FileEntry> >& files = dctx->getFileEntries();
+    for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i = files.begin(),
           eoi = files.end(); i != eoi; ++i) {
       (*i)->setMaxConnectionPerServer(maxConn);
     }
@@ -1507,7 +1507,7 @@ void changeOption
     group->setMaxUploadSpeedLimit(grOption->getAsInt(PREF_MAX_UPLOAD_LIMIT));
   }
 #ifdef ENABLE_BITTORRENT
-  const SharedHandle<BtObject>& btObject =
+  const std::shared_ptr<BtObject>& btObject =
     e->getBtRegistry()->get(group->getGID());
   if(btObject) {
     if(option.defined(PREF_BT_MAX_PEERS)) {
diff --git a/src/RpcMethodImpl.h b/src/RpcMethodImpl.h
index 72baf438..04265229 100644
--- a/src/RpcMethodImpl.h
+++ b/src/RpcMethodImpl.h
@@ -127,7 +127,7 @@ void toStringList(OutputIterator out, const List* src)
 
 class AddUriRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -138,7 +138,7 @@ public:
 
 class RemoveRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -149,7 +149,7 @@ public:
 
 class ForceRemoveRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -160,7 +160,7 @@ public:
 
 class PauseRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -171,7 +171,7 @@ public:
 
 class ForcePauseRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -182,7 +182,7 @@ public:
 
 class PauseAllRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -193,7 +193,7 @@ public:
 
 class ForcePauseAllRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -204,7 +204,7 @@ public:
 
 class UnpauseRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -215,7 +215,7 @@ public:
 
 class UnpauseAllRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -227,7 +227,7 @@ public:
 #ifdef ENABLE_BITTORRENT
 class AddTorrentRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -240,7 +240,7 @@ public:
 #ifdef ENABLE_METALINK
 class AddMetalinkRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -252,7 +252,7 @@ public:
 
 class PurgeDownloadResultRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -263,7 +263,7 @@ public:
 
 class RemoveDownloadResultRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -274,7 +274,7 @@ public:
 
 class GetUrisRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -285,7 +285,7 @@ public:
 
 class GetFilesRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -297,7 +297,7 @@ public:
 #ifdef ENABLE_BITTORRENT
 class GetPeersRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -309,7 +309,7 @@ public:
 
 class GetServersRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -320,7 +320,7 @@ public:
 
 class TellStatusRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -331,7 +331,7 @@ public:
 
 class TellActiveRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -374,9 +374,9 @@ private:
     return std::make_pair(first, last);
   }
 protected:
-  typedef IndexedList<a2_gid_t, SharedHandle<T> > ItemListType;
+  typedef IndexedList<a2_gid_t, std::shared_ptr<T> > ItemListType;
 
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e)
   {
     const Integer* offsetParam = checkRequiredParam<Integer>(req, 0);
@@ -391,9 +391,9 @@ protected:
     std::pair<typename ItemListType::const_iterator,
               typename ItemListType::const_iterator> range =
       getPaginationRange(offset, num, items.begin(), items.end());
-    SharedHandle<List> list = List::g();
+    std::shared_ptr<List> list = List::g();
     for(; range.first != range.second; ++range.first) {
-      SharedHandle<Dict> entryDict = Dict::g();
+      std::shared_ptr<Dict> entryDict = Dict::g();
       createEntry(entryDict, *range.first, e, keys);
       list->append(entryDict);
     }
@@ -406,8 +406,8 @@ protected:
   virtual const ItemListType& getItems(DownloadEngine* e) const = 0;
 
   virtual void createEntry
-  (const SharedHandle<Dict>& entryDict,
-   const SharedHandle<T>& item,
+  (const std::shared_ptr<Dict>& entryDict,
+   const std::shared_ptr<T>& item,
    DownloadEngine* e,
    const std::vector<std::string>& keys) const = 0;
 };
@@ -418,8 +418,8 @@ protected:
   virtual const RequestGroupList& getItems(DownloadEngine* e) const;
 
   virtual void createEntry
-  (const SharedHandle<Dict>& entryDict,
-   const SharedHandle<RequestGroup>& item,
+  (const std::shared_ptr<Dict>& entryDict,
+   const std::shared_ptr<RequestGroup>& item,
    DownloadEngine* e,
    const std::vector<std::string>& keys) const;
 public:
@@ -435,8 +435,8 @@ protected:
   virtual const DownloadResultList& getItems(DownloadEngine* e) const;
 
   virtual void createEntry
-  (const SharedHandle<Dict>& entryDict,
-   const SharedHandle<DownloadResult>& item,
+  (const std::shared_ptr<Dict>& entryDict,
+   const std::shared_ptr<DownloadResult>& item,
    DownloadEngine* e,
    const std::vector<std::string>& keys) const;
 public:
@@ -448,7 +448,7 @@ public:
 
 class ChangeOptionRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -459,7 +459,7 @@ public:
 
 class ChangeGlobalOptionRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -470,7 +470,7 @@ public:
 
 class GetVersionRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -481,7 +481,7 @@ public:
 
 class GetOptionRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -492,7 +492,7 @@ public:
 
 class GetGlobalOptionRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -503,7 +503,7 @@ public:
 
 class ChangePositionRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -514,7 +514,7 @@ public:
 
 class ChangeUriRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -525,7 +525,7 @@ public:
 
 class GetSessionInfoRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -536,7 +536,7 @@ public:
 
 class ShutdownRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -547,7 +547,7 @@ public:
 
 class GetGlobalStatRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -558,7 +558,7 @@ public:
 
 class ForceShutdownRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -569,7 +569,7 @@ public:
 
 class SystemMulticallRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 public:
   static const char* getMethodName()
@@ -580,36 +580,36 @@ public:
 
 class NoSuchMethodRpcMethod:public RpcMethod {
 protected:
-  virtual SharedHandle<ValueBase> process
+  virtual std::shared_ptr<ValueBase> process
   (const RpcRequest& req, DownloadEngine* e);
 };
 
 // Helper function to store data to entryDict from ds. This function
 // is used by tellStatus method.
 void gatherStoppedDownload
-(const SharedHandle<Dict>& entryDict, const SharedHandle<DownloadResult>& ds,
+(const std::shared_ptr<Dict>& entryDict, const std::shared_ptr<DownloadResult>& ds,
  const std::vector<std::string>& keys);
 
 // Helper function to store data to entryDict from group. This
 // function is used by tellStatus/tellActive/tellWaiting method
 void gatherProgressCommon
-(const SharedHandle<Dict>& entryDict, const SharedHandle<RequestGroup>& group,
+(const std::shared_ptr<Dict>& entryDict, const std::shared_ptr<RequestGroup>& group,
  const std::vector<std::string>& keys);
 
 #ifdef ENABLE_BITTORRENT
 // Helper function to store BitTorrent metadata from torrentAttrs.
 void gatherBitTorrentMetadata
-(const SharedHandle<Dict>& btDict,
- const SharedHandle<TorrentAttribute>& torrentAttrs);
+(const std::shared_ptr<Dict>& btDict,
+ const std::shared_ptr<TorrentAttribute>& torrentAttrs);
 #endif // ENABLE_BITTORRENT
 
 } // namespace rpc
 
 bool pauseRequestGroup
-(const SharedHandle<RequestGroup>& group, bool reserved,  bool forcePause);
+(const std::shared_ptr<RequestGroup>& group, bool reserved,  bool forcePause);
 
 void changeOption
-(const SharedHandle<RequestGroup>& group,
+(const std::shared_ptr<RequestGroup>& group,
  const Option& option,
  DownloadEngine* e);
 
diff --git a/src/RpcRequest.cc b/src/RpcRequest.cc
index af41a4a4..1ed1c1db 100644
--- a/src/RpcRequest.cc
+++ b/src/RpcRequest.cc
@@ -43,13 +43,13 @@ RpcRequest::RpcRequest()
 {}
 
 RpcRequest::RpcRequest(const std::string& methodName,
-                       const SharedHandle<List>& params)
+                       const std::shared_ptr<List>& params)
   : methodName(methodName), params(params), jsonRpc(false)
 {}
 
 RpcRequest::RpcRequest(const std::string& methodName,
-                       const SharedHandle<List>& params,
-                       const SharedHandle<ValueBase>& id)
+                       const std::shared_ptr<List>& params,
+                       const std::shared_ptr<ValueBase>& id)
   : methodName(methodName), params(params), id(id), jsonRpc(false)
 {}
 
diff --git a/src/RpcRequest.h b/src/RpcRequest.h
index a6017708..85b75a50 100644
--- a/src/RpcRequest.h
+++ b/src/RpcRequest.h
@@ -47,18 +47,18 @@ namespace rpc {
 
 struct RpcRequest {
   std::string methodName;
-  SharedHandle<List> params;
-  SharedHandle<ValueBase> id;
+  std::shared_ptr<List> params;
+  std::shared_ptr<ValueBase> id;
   bool jsonRpc;
 
   RpcRequest();
 
   RpcRequest(const std::string& methodName,
-             const SharedHandle<List>& params);
+             const std::shared_ptr<List>& params);
 
   RpcRequest(const std::string& methodName,
-             const SharedHandle<List>& params,
-             const SharedHandle<ValueBase>& id);
+             const std::shared_ptr<List>& params,
+             const std::shared_ptr<ValueBase>& id);
 
   ~RpcRequest();
 
diff --git a/src/RpcResponse.cc b/src/RpcResponse.cc
index ca7107d9..5f5cab1a 100644
--- a/src/RpcResponse.cc
+++ b/src/RpcResponse.cc
@@ -49,7 +49,7 @@ namespace rpc {
 
 namespace {
 template<typename OutputStream>
-void encodeValue(const SharedHandle<ValueBase>& value, OutputStream& o)
+void encodeValue(const std::shared_ptr<ValueBase>& value, OutputStream& o)
 {
   class XmlValueBaseVisitor:public ValueBaseVisitor {
   private:
@@ -104,7 +104,7 @@ void encodeValue(const SharedHandle<ValueBase>& value, OutputStream& o)
 namespace {
 template<typename OutputStream>
 std::string encodeAll
-(OutputStream& o, int code, const SharedHandle<ValueBase>& param)
+(OutputStream& o, int code, const std::shared_ptr<ValueBase>& param)
 {
   o << "<?xml version=\"1.0\"?>" << "<methodResponse>";
   if(code == 0) {
@@ -123,8 +123,8 @@ std::string encodeAll
 
 RpcResponse::RpcResponse
 (int code,
- const SharedHandle<ValueBase>& param,
- const SharedHandle<ValueBase>& id)
+ const std::shared_ptr<ValueBase>& param,
+ const std::shared_ptr<ValueBase>& id)
   : code(code), param(param), id(id)
 {}
 
@@ -166,14 +166,14 @@ template<typename OutputStream>
 OutputStream& encodeJsonAll
 (OutputStream& o,
  int code,
- const SharedHandle<ValueBase>& param,
- const SharedHandle<ValueBase>& id,
+ const std::shared_ptr<ValueBase>& param,
+ const std::shared_ptr<ValueBase>& id,
  const std::string& callback = A2STR::NIL)
 {
   if(!callback.empty()) {
     o << callback << "(";
   }
-  SharedHandle<Dict> dict = Dict::g();
+  std::shared_ptr<Dict> dict = Dict::g();
   dict->put("jsonrpc", "2.0");
   dict->put("id", id);
   if(code == 0) {
diff --git a/src/RpcResponse.h b/src/RpcResponse.h
index 31f43928..aaa401ea 100644
--- a/src/RpcResponse.h
+++ b/src/RpcResponse.h
@@ -50,14 +50,14 @@ struct RpcResponse {
   // 0 for success, non-zero for error
   int code;
 
-  SharedHandle<ValueBase> param;
+  std::shared_ptr<ValueBase> param;
 
-  SharedHandle<ValueBase> id;
+  std::shared_ptr<ValueBase> id;
 
   RpcResponse
   (int code,
-   const SharedHandle<ValueBase>& param,
-   const SharedHandle<ValueBase>& id);
+   const std::shared_ptr<ValueBase>& param,
+   const std::shared_ptr<ValueBase>& id);
 
   RpcResponse(const RpcResponse& c);
 
diff --git a/src/SeedCheckCommand.cc b/src/SeedCheckCommand.cc
index e95c5079..fc536427 100644
--- a/src/SeedCheckCommand.cc
+++ b/src/SeedCheckCommand.cc
@@ -49,7 +49,7 @@ SeedCheckCommand::SeedCheckCommand
 (cuid_t cuid,
  RequestGroup* requestGroup,
  DownloadEngine* e,
- const SharedHandle<SeedCriteria>& seedCriteria)
+ const std::shared_ptr<SeedCriteria>& seedCriteria)
   : Command(cuid),
     requestGroup_(requestGroup),
     e_(e),
@@ -89,18 +89,18 @@ bool SeedCheckCommand::execute() {
 }
 
 void SeedCheckCommand::setSeedCriteria
-(const SharedHandle<SeedCriteria>& seedCriteria)
+(const std::shared_ptr<SeedCriteria>& seedCriteria)
 {
   seedCriteria_ = seedCriteria;
 }
 
-void SeedCheckCommand::setBtRuntime(const SharedHandle<BtRuntime>& btRuntime)
+void SeedCheckCommand::setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime)
 {
   btRuntime_ = btRuntime;
 }
 
 void SeedCheckCommand::setPieceStorage
-(const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
diff --git a/src/SeedCheckCommand.h b/src/SeedCheckCommand.h
index bcc33bf0..127211ab 100644
--- a/src/SeedCheckCommand.h
+++ b/src/SeedCheckCommand.h
@@ -36,7 +36,8 @@
 #define D_SEED_CHECK_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -51,25 +52,25 @@ class SeedCheckCommand : public Command
 private:
   RequestGroup* requestGroup_;
   DownloadEngine* e_;
-  SharedHandle<PieceStorage> pieceStorage_;
-  SharedHandle<BtRuntime> btRuntime_;
-  SharedHandle<SeedCriteria> seedCriteria_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
+  std::shared_ptr<BtRuntime> btRuntime_;
+  std::shared_ptr<SeedCriteria> seedCriteria_;
   bool checkStarted_;
 public:
   SeedCheckCommand(cuid_t cuid,
                    RequestGroup* requestGroup,
                    DownloadEngine* e,
-                   const SharedHandle<SeedCriteria>& seedCriteria);
+                   const std::shared_ptr<SeedCriteria>& seedCriteria);
 
   virtual ~SeedCheckCommand();
 
   virtual bool execute();
 
-  void setSeedCriteria(const SharedHandle<SeedCriteria>& seedCriteria);
+  void setSeedCriteria(const std::shared_ptr<SeedCriteria>& seedCriteria);
 
-  void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime);
+  void setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime);
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 };
 
 } // namespace aria2
diff --git a/src/SeedCriteria.h b/src/SeedCriteria.h
index 5129de62..6c182b59 100644
--- a/src/SeedCriteria.h
+++ b/src/SeedCriteria.h
@@ -36,7 +36,6 @@
 #define D_SEED_CRITERIA_H
 
 #include "common.h"
-#include "SharedHandle.h"
 
 namespace aria2 {
 
diff --git a/src/Segment.h b/src/Segment.h
index bc87cec9..dd17826c 100644
--- a/src/Segment.h
+++ b/src/Segment.h
@@ -39,8 +39,7 @@
 
 #include <stdint.h>
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -83,7 +82,7 @@ public:
 
   virtual void clear(WrDiskCache* diskCache) = 0;
 
-  virtual SharedHandle<Piece> getPiece() const = 0;
+  virtual std::shared_ptr<Piece> getPiece() const = 0;
 
   bool operator==(const Segment& segment) const
   {
diff --git a/src/SegmentMan.cc b/src/SegmentMan.cc
index e2c8947f..b872682f 100644
--- a/src/SegmentMan.cc
+++ b/src/SegmentMan.cc
@@ -58,15 +58,15 @@
 
 namespace aria2 {
 
-SegmentEntry::SegmentEntry(cuid_t cuid, const SharedHandle<Segment>& segment)
+SegmentEntry::SegmentEntry(cuid_t cuid, const std::shared_ptr<Segment>& segment)
   : cuid(cuid), segment(segment)
 {}
 
 SegmentEntry::~SegmentEntry() {}
 
 SegmentMan::SegmentMan
-(const SharedHandle<DownloadContext>& downloadContext,
- const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<DownloadContext>& downloadContext,
+ const std::shared_ptr<PieceStorage>& pieceStorage)
   : downloadContext_(downloadContext),
     pieceStorage_(pieceStorage),
     ignoreBitfield_(downloadContext->getPieceLength(),
@@ -101,20 +101,20 @@ int64_t SegmentMan::getTotalLength() const
   }
 }
 
-void SegmentMan::setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage)
+void SegmentMan::setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
 
 void SegmentMan::setDownloadContext
-(const SharedHandle<DownloadContext>& downloadContext)
+(const std::shared_ptr<DownloadContext>& downloadContext)
 {
   downloadContext_ = downloadContext;
 }
 
 namespace {
 void flushWrDiskCache(WrDiskCache* wrDiskCache,
-                      const SharedHandle<Piece>& piece)
+                      const std::shared_ptr<Piece>& piece)
 {
   piece->flushWrCache(wrDiskCache);
   if(piece->getWrDiskCacheEntry()->getError() !=
@@ -128,11 +128,11 @@ void flushWrDiskCache(WrDiskCache* wrDiskCache,
 }
 } // namespace
 
-SharedHandle<Segment> SegmentMan::checkoutSegment
-(cuid_t cuid, const SharedHandle<Piece>& piece)
+std::shared_ptr<Segment> SegmentMan::checkoutSegment
+(cuid_t cuid, const std::shared_ptr<Piece>& piece)
 {
   if(!piece) {
-    return SharedHandle<Segment>();
+    return std::shared_ptr<Segment>();
   }
   A2_LOG_DEBUG(fmt("Attach segment#%lu to CUID#%" PRId64 ".",
                    static_cast<unsigned long>(piece->getIndex()),
@@ -148,13 +148,13 @@ SharedHandle<Segment> SegmentMan::checkoutSegment
   }
 
   piece->setUsedBySegment(true);
-  SharedHandle<Segment> segment;
+  std::shared_ptr<Segment> segment;
   if(piece->getLength() == 0) {
     segment.reset(new GrowSegment(piece));
   } else {
     segment.reset(new PiecedSegment(downloadContext_->getPieceLength(), piece));
   }
-  SharedHandle<SegmentEntry> entry(new SegmentEntry(cuid, segment));
+  std::shared_ptr<SegmentEntry> entry(new SegmentEntry(cuid, segment));
   usedSegmentEntries_.push_back(entry);
   A2_LOG_DEBUG(fmt("index=%lu, length=%d, segmentLength=%d,"
                    " writtenLength=%d",
@@ -183,20 +183,20 @@ SharedHandle<Segment> SegmentMan::checkoutSegment
 }
 
 void SegmentMan::getInFlightSegment
-(std::vector<SharedHandle<Segment> >& segments, cuid_t cuid)
+(std::vector<std::shared_ptr<Segment> >& segments, cuid_t cuid)
 {
   for(SegmentEntries::const_iterator itr = usedSegmentEntries_.begin(),
         eoi = usedSegmentEntries_.end(); itr != eoi; ++itr) {
-    const SharedHandle<SegmentEntry>& segmentEntry = *itr;
+    const std::shared_ptr<SegmentEntry>& segmentEntry = *itr;
     if(segmentEntry->cuid == cuid) {
       segments.push_back(segmentEntry->segment);
     }
   }
 }
 
-SharedHandle<Segment> SegmentMan::getSegment(cuid_t cuid, size_t minSplitSize)
+std::shared_ptr<Segment> SegmentMan::getSegment(cuid_t cuid, size_t minSplitSize)
 {
-  SharedHandle<Piece> piece =
+  std::shared_ptr<Piece> piece =
     pieceStorage_->getMissingPiece
     (minSplitSize,
      ignoreBitfield_.getFilterBitfield(), ignoreBitfield_.getBitfieldLength(),
@@ -205,18 +205,18 @@ SharedHandle<Segment> SegmentMan::getSegment(cuid_t cuid, size_t minSplitSize)
 }
 
 void SegmentMan::getSegment
-(std::vector<SharedHandle<Segment> >& segments,
+(std::vector<std::shared_ptr<Segment> >& segments,
  cuid_t cuid,
  size_t minSplitSize,
- const SharedHandle<FileEntry>& fileEntry,
+ const std::shared_ptr<FileEntry>& fileEntry,
  size_t maxSegments)
 {
   BitfieldMan filter(ignoreBitfield_);
   filter.enableFilter();
   filter.addNotFilter(fileEntry->getOffset(), fileEntry->getLength());
-  std::vector<SharedHandle<Segment> > pending;
+  std::vector<std::shared_ptr<Segment> > pending;
   while(segments.size() < maxSegments) {
-    SharedHandle<Segment> segment =
+    std::shared_ptr<Segment> segment =
       checkoutSegment(cuid,
                       pieceStorage_->getMissingPiece
                       (minSplitSize,
@@ -232,56 +232,56 @@ void SegmentMan::getSegment
       segments.push_back(segment);
     }
   }
-  for(std::vector<SharedHandle<Segment> >::const_iterator i = pending.begin(),
+  for(std::vector<std::shared_ptr<Segment> >::const_iterator i = pending.begin(),
         eoi = pending.end(); i != eoi; ++i) {
     cancelSegment(cuid, *i);
   }
 }
 
-SharedHandle<Segment> SegmentMan::getSegmentWithIndex
+std::shared_ptr<Segment> SegmentMan::getSegmentWithIndex
 (cuid_t cuid, size_t index) {
   if(index > 0 && downloadContext_->getNumPieces() <= index) {
-    return SharedHandle<Segment>();
+    return std::shared_ptr<Segment>();
   }
   return checkoutSegment(cuid, pieceStorage_->getMissingPiece(index, cuid));
 }
 
-SharedHandle<Segment> SegmentMan::getCleanSegmentIfOwnerIsIdle
+std::shared_ptr<Segment> SegmentMan::getCleanSegmentIfOwnerIsIdle
 (cuid_t cuid, size_t index)
 {
   if(index > 0 && downloadContext_->getNumPieces() <= index) {
-    return SharedHandle<Segment>();
+    return std::shared_ptr<Segment>();
   }
   for(SegmentEntries::const_iterator itr = usedSegmentEntries_.begin(),
         eoi = usedSegmentEntries_.end(); itr != eoi; ++itr) {
-    const SharedHandle<SegmentEntry>& segmentEntry = *itr;
+    const std::shared_ptr<SegmentEntry>& segmentEntry = *itr;
     if(segmentEntry->segment->getIndex() == index) {
       if(segmentEntry->segment->getWrittenLength() > 0) {
-        return SharedHandle<Segment>();
+        return std::shared_ptr<Segment>();
       }
       if(segmentEntry->cuid == cuid) {
         return segmentEntry->segment;
       }
       cuid_t owner = segmentEntry->cuid;
-      SharedHandle<PeerStat> ps = getPeerStat(owner);
+      std::shared_ptr<PeerStat> ps = getPeerStat(owner);
       if(!ps || ps->getStatus() == NetStat::IDLE) {
         cancelSegment(owner);
         return getSegmentWithIndex(cuid, index);
       } else {
-        return SharedHandle<Segment>();
+        return std::shared_ptr<Segment>();
       }
     }
   }
-  return SharedHandle<Segment>();
+  return std::shared_ptr<Segment>();
 }
 
 void SegmentMan::cancelSegmentInternal
 (cuid_t cuid,
- const SharedHandle<Segment>& segment)
+ const std::shared_ptr<Segment>& segment)
 {
   A2_LOG_DEBUG(fmt("Canceling segment#%lu",
                    static_cast<unsigned long>(segment->getIndex())));
-  const SharedHandle<Piece>& piece = segment->getPiece();
+  const std::shared_ptr<Piece>& piece = segment->getPiece();
   // TODO In PieceStorage::cancelPiece(), WrDiskCacheEntry may be
   // released. Flush first.
   if(piece->getWrDiskCacheEntry()) {
@@ -316,7 +316,7 @@ void SegmentMan::cancelSegment(cuid_t cuid) {
 }
 
 void SegmentMan::cancelSegment
-(cuid_t cuid, const SharedHandle<Segment>& segment)
+(cuid_t cuid, const std::shared_ptr<Segment>& segment)
 {
   for(SegmentEntries::iterator itr = usedSegmentEntries_.begin(),
         eoi = usedSegmentEntries_.end(); itr != eoi;) {
@@ -332,7 +332,7 @@ void SegmentMan::cancelSegment
 
 void SegmentMan::cancelAllSegments()
 {
-  for(std::deque<SharedHandle<SegmentEntry> >::iterator itr =
+  for(std::deque<std::shared_ptr<SegmentEntry> >::iterator itr =
         usedSegmentEntries_.begin(), eoi = usedSegmentEntries_.end();
       itr != eoi; ++itr) {
     cancelSegmentInternal((*itr)->cuid, (*itr)->segment);
@@ -348,11 +348,11 @@ void SegmentMan::eraseSegmentWrittenLengthMemo()
 namespace {
 class FindSegmentEntry {
 private:
-  SharedHandle<Segment> segment_;
+  std::shared_ptr<Segment> segment_;
 public:
-  FindSegmentEntry(const SharedHandle<Segment>& segment):segment_(segment) {}
+  FindSegmentEntry(const std::shared_ptr<Segment>& segment):segment_(segment) {}
 
-  bool operator()(const SharedHandle<SegmentEntry>& segmentEntry) const
+  bool operator()(const std::shared_ptr<SegmentEntry>& segmentEntry) const
   {
     return segmentEntry->segment->getIndex() == segment_->getIndex();
   }
@@ -360,7 +360,7 @@ public:
 } // namespace
 
 bool SegmentMan::completeSegment
-(cuid_t cuid, const SharedHandle<Segment>& segment) {
+(cuid_t cuid, const std::shared_ptr<Segment>& segment) {
   pieceStorage_->completePiece(segment->getPiece());
   pieceStorage_->advertisePiece(cuid, segment->getPiece()->getIndex());
   SegmentEntries::iterator itr = std::find_if(usedSegmentEntries_.begin(),
@@ -386,31 +386,31 @@ int64_t SegmentMan::getDownloadLength() const {
   }
 }
 
-void SegmentMan::registerPeerStat(const SharedHandle<PeerStat>& peerStat)
+void SegmentMan::registerPeerStat(const std::shared_ptr<PeerStat>& peerStat)
 {
   peerStats_.push_back(peerStat);
 }
 
-SharedHandle<PeerStat> SegmentMan::getPeerStat(cuid_t cuid) const
+std::shared_ptr<PeerStat> SegmentMan::getPeerStat(cuid_t cuid) const
 {
-  for(std::vector<SharedHandle<PeerStat> >::const_iterator i =
+  for(std::vector<std::shared_ptr<PeerStat> >::const_iterator i =
         peerStats_.begin(), eoi = peerStats_.end(); i != eoi; ++i) {
     if((*i)->getCuid() == cuid) {
       return *i;
     }
   }
-  return SharedHandle<PeerStat>();
+  return std::shared_ptr<PeerStat>();
 }
 
 namespace {
 class PeerStatHostProtoEqual {
 private:
-  const SharedHandle<PeerStat>& peerStat_;
+  const std::shared_ptr<PeerStat>& peerStat_;
 public:
-  PeerStatHostProtoEqual(const SharedHandle<PeerStat>& peerStat):
+  PeerStatHostProtoEqual(const std::shared_ptr<PeerStat>& peerStat):
     peerStat_(peerStat) {}
 
-  bool operator()(const SharedHandle<PeerStat>& p) const
+  bool operator()(const std::shared_ptr<PeerStat>& p) const
   {
     return peerStat_->getHostname() == p->getHostname() &&
       peerStat_->getProtocol() == p->getProtocol();
@@ -418,9 +418,9 @@ public:
 };
 } // namespace
 
-void SegmentMan::updateFastestPeerStat(const SharedHandle<PeerStat>& peerStat)
+void SegmentMan::updateFastestPeerStat(const std::shared_ptr<PeerStat>& peerStat)
 {
-  std::vector<SharedHandle<PeerStat> >::iterator i =
+  std::vector<std::shared_ptr<PeerStat> >::iterator i =
     std::find_if(fastestPeerStats_.begin(), fastestPeerStats_.end(),
                  PeerStatHostProtoEqual(peerStat));
   if(i == fastestPeerStats_.end()) {
@@ -446,7 +446,7 @@ size_t SegmentMan::countFreePieceFrom(size_t index) const
   return downloadContext_->getNumPieces()-index;
 }
 
-void SegmentMan::ignoreSegmentFor(const SharedHandle<FileEntry>& fileEntry)
+void SegmentMan::ignoreSegmentFor(const std::shared_ptr<FileEntry>& fileEntry)
 {
   A2_LOG_DEBUG(fmt("ignoring segment for path=%s, offset=%" PRId64
                    ", length=%" PRId64 "",
@@ -456,7 +456,7 @@ void SegmentMan::ignoreSegmentFor(const SharedHandle<FileEntry>& fileEntry)
   ignoreBitfield_.addFilter(fileEntry->getOffset(), fileEntry->getLength());
 }
 
-void SegmentMan::recognizeSegmentFor(const SharedHandle<FileEntry>& fileEntry)
+void SegmentMan::recognizeSegmentFor(const std::shared_ptr<FileEntry>& fileEntry)
 {
   ignoreBitfield_.removeFilter(fileEntry->getOffset(), fileEntry->getLength());
 }
diff --git a/src/SegmentMan.h b/src/SegmentMan.h
index 132f8f28..60dbd625 100644
--- a/src/SegmentMan.h
+++ b/src/SegmentMan.h
@@ -40,8 +40,8 @@
 #include <deque>
 #include <vector>
 #include <map>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimerA2.h"
 #include "Command.h"
 #include "BitfieldMan.h"
@@ -58,9 +58,9 @@ class FileEntry;
 
 struct SegmentEntry {
   cuid_t cuid;
-  SharedHandle<Segment> segment;
+  std::shared_ptr<Segment> segment;
 
-  SegmentEntry(cuid_t cuid, const SharedHandle<Segment>& segment);
+  SegmentEntry(cuid_t cuid, const std::shared_ptr<Segment>& segment);
   ~SegmentEntry();
 
   // Don't allow copying
@@ -68,16 +68,16 @@ struct SegmentEntry {
   SegmentEntry& operator=(const SegmentEntry&);
 };
 
-typedef std::deque<SharedHandle<SegmentEntry> > SegmentEntries;
+typedef std::deque<std::shared_ptr<SegmentEntry> > SegmentEntries;
 
 /**
  * This class holds the download progress of the one download entry.
  */
 class SegmentMan {
 private:
-  SharedHandle<DownloadContext> downloadContext_;
+  std::shared_ptr<DownloadContext> downloadContext_;
 
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
 
   SegmentEntries usedSegmentEntries_;
 
@@ -86,20 +86,20 @@ private:
   std::map<size_t, int32_t> segmentWrittenLengthMemo_;
 
   // Used for calculating download speed.
-  std::vector<SharedHandle<PeerStat> > peerStats_;
+  std::vector<std::shared_ptr<PeerStat> > peerStats_;
 
   // Keep track of fastest PeerStat for each server
-  std::vector<SharedHandle<PeerStat> > fastestPeerStats_;
+  std::vector<std::shared_ptr<PeerStat> > fastestPeerStats_;
 
   BitfieldMan ignoreBitfield_;
 
-  SharedHandle<Segment> checkoutSegment(cuid_t cuid,
-                                        const SharedHandle<Piece>& piece);
+  std::shared_ptr<Segment> checkoutSegment(cuid_t cuid,
+                                        const std::shared_ptr<Piece>& piece);
 
-  void cancelSegmentInternal(cuid_t cuid, const SharedHandle<Segment>& segment);
+  void cancelSegmentInternal(cuid_t cuid, const std::shared_ptr<Segment>& segment);
 public:
-  SegmentMan(const SharedHandle<DownloadContext>& downloadContext,
-             const SharedHandle<PieceStorage>& pieceStorage);
+  SegmentMan(const std::shared_ptr<DownloadContext>& downloadContext,
+             const std::shared_ptr<PieceStorage>& pieceStorage);
 
   ~SegmentMan();
 
@@ -126,17 +126,17 @@ public:
    * Fill segments which are assigned to the command whose CUID is cuid.
    * This function doesn't clear passed segments.
    */
-  void getInFlightSegment(std::vector<SharedHandle<Segment> >& segments,
+  void getInFlightSegment(std::vector<std::shared_ptr<Segment> >& segments,
                           cuid_t cuid);
 
-  SharedHandle<Segment> getSegment(cuid_t cuid, size_t minSplitSize);
+  std::shared_ptr<Segment> getSegment(cuid_t cuid, size_t minSplitSize);
 
   // Checkouts segments in the range of fileEntry and push back to
   // segments until segments.size() < maxSegments holds false
-  void getSegment(std::vector<SharedHandle<Segment> >& segments,
+  void getSegment(std::vector<std::shared_ptr<Segment> >& segments,
                   cuid_t cuid,
                   size_t minSplitSize,
-                  const SharedHandle<FileEntry>& fileEntry,
+                  const std::shared_ptr<FileEntry>& fileEntry,
                   size_t maxSegments);
 
   /**
@@ -145,13 +145,13 @@ public:
    * to another cuid or has been downloaded, then returns a segment instance
    * whose isNull call is true.
    */
-  SharedHandle<Segment> getSegmentWithIndex(cuid_t cuid, size_t index);
+  std::shared_ptr<Segment> getSegmentWithIndex(cuid_t cuid, size_t index);
 
   // Returns a currently used segment whose index is index and written
   // length is 0.  The current owner(in idle state) of segment cancels
   // the segment and cuid command acquires the ownership of the
   // segment.  If no such segment exists, returns null.
-  SharedHandle<Segment> getCleanSegmentIfOwnerIsIdle(cuid_t cuid, size_t index);
+  std::shared_ptr<Segment> getCleanSegmentIfOwnerIsIdle(cuid_t cuid, size_t index);
 
   /**
    * Updates download status.
@@ -163,7 +163,7 @@ public:
    */
   void cancelSegment(cuid_t cuid);
 
-  void cancelSegment(cuid_t cuid, const SharedHandle<Segment>& segment);
+  void cancelSegment(cuid_t cuid, const std::shared_ptr<Segment>& segment);
 
   void cancelAllSegments();
 
@@ -172,17 +172,17 @@ public:
   /**
    * Tells SegmentMan that the segment has been downloaded successfully.
    */
-  bool completeSegment(cuid_t cuid, const SharedHandle<Segment>& segment);
+  bool completeSegment(cuid_t cuid, const std::shared_ptr<Segment>& segment);
 
   /**
    * Injects PieceStorage.
    */
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 
   /**
    * Injects DownloadContext.
    */
-  void setDownloadContext(const SharedHandle<DownloadContext>& downloadContext);
+  void setDownloadContext(const std::shared_ptr<DownloadContext>& downloadContext);
 
   /**
    * Returns true if the segment whose index is index has been downloaded.
@@ -197,22 +197,22 @@ public:
   // If there is inactive PeerStat in peerStats_, it is replaced with
   // given peerStat. If no such PeerStat exist, the given peerStat is
   // inserted.
-  void registerPeerStat(const SharedHandle<PeerStat>& peerStat);
+  void registerPeerStat(const std::shared_ptr<PeerStat>& peerStat);
 
-  const std::vector<SharedHandle<PeerStat> >& getPeerStats() const
+  const std::vector<std::shared_ptr<PeerStat> >& getPeerStats() const
   {
     return peerStats_;
   }
 
-  SharedHandle<PeerStat> getPeerStat(cuid_t cuid) const;
+  std::shared_ptr<PeerStat> getPeerStat(cuid_t cuid) const;
 
   // If there is slower PeerStat than given peerStat for the same
   // hostname and protocol in fastestPeerStats_, the former is
   // replaced with latter. If there are no PeerStat with same hostname
   // and protocol with given peerStat, given peerStat is inserted.
-  void updateFastestPeerStat(const SharedHandle<PeerStat>& peerStat);
+  void updateFastestPeerStat(const std::shared_ptr<PeerStat>& peerStat);
 
-  const std::vector<SharedHandle<PeerStat> >& getFastestPeerStats() const
+  const std::vector<std::shared_ptr<PeerStat> >& getFastestPeerStats() const
   {
     return fastestPeerStats_;
   }
@@ -220,10 +220,10 @@ public:
   size_t countFreePieceFrom(size_t index) const;
 
   // Excludes segments that fileEntry covers from segment selection.
-  void ignoreSegmentFor(const SharedHandle<FileEntry>& fileEntry);
+  void ignoreSegmentFor(const std::shared_ptr<FileEntry>& fileEntry);
 
   // Includes segments that fileEntry covers in segment selection.
-  void recognizeSegmentFor(const SharedHandle<FileEntry>& fileEntry);
+  void recognizeSegmentFor(const std::shared_ptr<FileEntry>& fileEntry);
 
   bool allSegmentsIgnored() const;
 };
diff --git a/src/SelectEventPoll.cc b/src/SelectEventPoll.cc
index ba0e00ca..c5682b5b 100644
--- a/src/SelectEventPoll.cc
+++ b/src/SelectEventPoll.cc
@@ -126,7 +126,7 @@ int SelectEventPoll::SocketEntry::getEvents()
 #ifdef ENABLE_ASYNC_DNS
 
 SelectEventPoll::AsyncNameResolverEntry::AsyncNameResolverEntry
-(const SharedHandle<AsyncNameResolver>& nameResolver, Command* command):
+(const std::shared_ptr<AsyncNameResolver>& nameResolver, Command* command):
   nameResolver_(nameResolver), command_(command) {}
 
 int SelectEventPoll::AsyncNameResolverEntry::getFds
@@ -183,7 +183,7 @@ void SelectEventPoll::poll(const struct timeval& tv)
 
   for(AsyncNameResolverEntrySet::iterator itr = nameResolverEntries_.begin(),
         eoi = nameResolverEntries_.end(); itr != eoi; ++itr) {
-    const SharedHandle<AsyncNameResolverEntry>& entry = *itr;
+    const std::shared_ptr<AsyncNameResolverEntry>& entry = *itr;
     int fd = entry->getFds(&rfds, &wfds);
     // TODO force error if fd == 0
     if(fdmax_ < fd) {
@@ -280,7 +280,7 @@ void SelectEventPoll::updateFdSet()
 bool SelectEventPoll::addEvents(sock_t socket, Command* command,
                                 EventPoll::EventType events)
 {
-  SharedHandle<SocketEntry> socketEntry(new SocketEntry(socket));
+  std::shared_ptr<SocketEntry> socketEntry(new SocketEntry(socket));
   SocketEntrySet::iterator i = socketEntries_.lower_bound(socketEntry);
   if(i != socketEntries_.end() && *(*i) == *socketEntry) {
     (*i)->addCommandEvent(command, events);
@@ -295,7 +295,7 @@ bool SelectEventPoll::addEvents(sock_t socket, Command* command,
 bool SelectEventPoll::deleteEvents(sock_t socket, Command* command,
                                    EventPoll::EventType events)
 {
-  SharedHandle<SocketEntry> socketEntry(new SocketEntry(socket));
+  std::shared_ptr<SocketEntry> socketEntry(new SocketEntry(socket));
   SocketEntrySet::iterator i = socketEntries_.find(socketEntry);
   if(i == socketEntries_.end()) {
     A2_LOG_DEBUG(fmt("Socket %d is not found in SocketEntries.", socket));
@@ -312,9 +312,9 @@ bool SelectEventPoll::deleteEvents(sock_t socket, Command* command,
 
 #ifdef ENABLE_ASYNC_DNS
 bool SelectEventPoll::addNameResolver
-(const SharedHandle<AsyncNameResolver>& resolver, Command* command)
+(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
-  SharedHandle<AsyncNameResolverEntry> entry
+  std::shared_ptr<AsyncNameResolverEntry> entry
     (new AsyncNameResolverEntry(resolver, command));
   AsyncNameResolverEntrySet::iterator itr =
     nameResolverEntries_.lower_bound(entry);
@@ -327,9 +327,9 @@ bool SelectEventPoll::addNameResolver
 }
 
 bool SelectEventPoll::deleteNameResolver
-(const SharedHandle<AsyncNameResolver>& resolver, Command* command)
+(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
-  SharedHandle<AsyncNameResolverEntry> entry
+  std::shared_ptr<AsyncNameResolverEntry> entry
     (new AsyncNameResolverEntry(resolver, command));
   return nameResolverEntries_.erase(entry) == 1;
 }
diff --git a/src/SelectEventPoll.h b/src/SelectEventPoll.h
index f4eeabe6..56623c00 100644
--- a/src/SelectEventPoll.h
+++ b/src/SelectEventPoll.h
@@ -133,12 +133,12 @@ private:
 
   class AsyncNameResolverEntry {
   private:
-    SharedHandle<AsyncNameResolver> nameResolver_;
+    std::shared_ptr<AsyncNameResolver> nameResolver_;
 
     Command* command_;
 
   public:
-    AsyncNameResolverEntry(const SharedHandle<AsyncNameResolver>& nameResolver,
+    AsyncNameResolverEntry(const std::shared_ptr<AsyncNameResolver>& nameResolver,
                            Command* command);
 
     bool operator==(const AsyncNameResolverEntry& entry)
@@ -164,12 +164,12 @@ private:
   fd_set wfdset_;
   sock_t fdmax_;
 
-  typedef std::set<SharedHandle<SocketEntry>,
-                   DerefLess<SharedHandle<SocketEntry> > > SocketEntrySet;
+  typedef std::set<std::shared_ptr<SocketEntry>,
+                   DerefLess<std::shared_ptr<SocketEntry> > > SocketEntrySet;
   SocketEntrySet socketEntries_;
 #ifdef ENABLE_ASYNC_DNS
-  typedef std::set<SharedHandle<AsyncNameResolverEntry>,
-                   DerefLess<SharedHandle<AsyncNameResolverEntry> > >
+  typedef std::set<std::shared_ptr<AsyncNameResolverEntry>,
+                   DerefLess<std::shared_ptr<AsyncNameResolverEntry> > >
   AsyncNameResolverEntrySet;
   AsyncNameResolverEntrySet nameResolverEntries_;
 #endif // ENABLE_ASYNC_DNS
@@ -195,10 +195,10 @@ public:
                             Command* command, EventPoll::EventType events);
 #ifdef ENABLE_ASYNC_DNS
 
-  virtual bool addNameResolver(const SharedHandle<AsyncNameResolver>& resolver,
+  virtual bool addNameResolver(const std::shared_ptr<AsyncNameResolver>& resolver,
                                Command* command);
   virtual bool deleteNameResolver
-  (const SharedHandle<AsyncNameResolver>& resolver, Command* command);
+  (const std::shared_ptr<AsyncNameResolver>& resolver, Command* command);
 #endif // ENABLE_ASYNC_DNS
 };
 
diff --git a/src/SequentialDispatcherCommand.h b/src/SequentialDispatcherCommand.h
index 005d226f..9e0f1e36 100644
--- a/src/SequentialDispatcherCommand.h
+++ b/src/SequentialDispatcherCommand.h
@@ -36,7 +36,9 @@
 #define D_SEQUENTIAL_DISPATCHER_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "SequentialPicker.h"
 #include "DownloadEngine.h"
 #include "RequestGroupMan.h"
@@ -48,7 +50,7 @@ class DownloadEngine;
 template<typename T>
 class SequentialDispatcherCommand : public Command {
 private:
-  SharedHandle<SequentialPicker<T> > picker_;
+  std::shared_ptr<SequentialPicker<T> > picker_;
 
   DownloadEngine* e_;
 protected:
@@ -58,7 +60,7 @@ protected:
   }
 public:
   SequentialDispatcherCommand(cuid_t cuid,
-                              const SharedHandle<SequentialPicker<T> >& picker,
+                              const std::shared_ptr<SequentialPicker<T> >& picker,
                               DownloadEngine* e):
     Command(cuid), picker_(picker), e_(e)
   {
@@ -81,7 +83,7 @@ public:
   }
 
 protected:
-  virtual Command* createCommand(const SharedHandle<T>& entry) = 0;
+  virtual Command* createCommand(const std::shared_ptr<T>& entry) = 0;
 };
 
 } // namespace aria2
diff --git a/src/SequentialPicker.h b/src/SequentialPicker.h
index fac4ac45..6fbb984e 100644
--- a/src/SequentialPicker.h
+++ b/src/SequentialPicker.h
@@ -38,23 +38,22 @@
 #include "common.h"
 
 #include <deque>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
 template<typename T>
 class SequentialPicker {
 private:
-  std::deque<SharedHandle<T> > entries_;
-  SharedHandle<T> pickedEntry_;
+  std::deque<std::shared_ptr<T> > entries_;
+  std::shared_ptr<T> pickedEntry_;
 public:
   bool isPicked() const
   {
-    return pickedEntry_;
+    return pickedEntry_.get();
   }
 
-  const SharedHandle<T>& getPickedEntry() const
+  const std::shared_ptr<T>& getPickedEntry() const
   {
     return pickedEntry_;
   }
@@ -69,9 +68,9 @@ public:
     return !entries_.empty();
   }
 
-  SharedHandle<T> pickNext()
+  std::shared_ptr<T> pickNext()
   {
-    SharedHandle<T> r;
+    std::shared_ptr<T> r;
     if(hasNext()) {
       r = entries_.front();
       entries_.pop_front();
@@ -80,7 +79,7 @@ public:
     return r;
   }
 
-  void pushEntry(const SharedHandle<T>& entry)
+  void pushEntry(const std::shared_ptr<T>& entry)
   {
     entries_.push_back(entry);
   }
diff --git a/src/ServerStat.h b/src/ServerStat.h
index 6bd33678..7ef66681 100644
--- a/src/ServerStat.h
+++ b/src/ServerStat.h
@@ -38,8 +38,8 @@
 
 #include <string>
 #include <iosfwd>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimeA2.h"
 
 namespace aria2 {
@@ -170,8 +170,8 @@ private:
 class ServerStatFaster {
 public:
   bool operator()
-  (const std::pair<SharedHandle<ServerStat>, std::string> lhs,
-   const std::pair<SharedHandle<ServerStat>, std::string> rhs) const
+  (const std::pair<std::shared_ptr<ServerStat>, std::string> lhs,
+   const std::pair<std::shared_ptr<ServerStat>, std::string> rhs) const
   {
     return lhs.first->getDownloadSpeed() > rhs.first->getDownloadSpeed();
   }
diff --git a/src/ServerStatMan.cc b/src/ServerStatMan.cc
index 81ae7db5..ddeca299 100644
--- a/src/ServerStatMan.cc
+++ b/src/ServerStatMan.cc
@@ -56,19 +56,19 @@ ServerStatMan::ServerStatMan() {}
 
 ServerStatMan::~ServerStatMan() {}
 
-SharedHandle<ServerStat> ServerStatMan::find(const std::string& hostname,
+std::shared_ptr<ServerStat> ServerStatMan::find(const std::string& hostname,
                                              const std::string& protocol) const
 {
-  SharedHandle<ServerStat> ss(new ServerStat(hostname, protocol));
+  std::shared_ptr<ServerStat> ss(new ServerStat(hostname, protocol));
   ServerStatSet::iterator i = serverStats_.find(ss);
   if(i == serverStats_.end()) {
-    return SharedHandle<ServerStat>();
+    return std::shared_ptr<ServerStat>();
   } else {
     return *i;
   }
 }
 
-bool ServerStatMan::add(const SharedHandle<ServerStat>& serverStat)
+bool ServerStatMan::add(const std::shared_ptr<ServerStat>& serverStat)
 {
   ServerStatSet::iterator i = serverStats_.lower_bound(serverStat);
   if(i != serverStats_.end() && *(*i) == *serverStat) {
@@ -195,7 +195,7 @@ bool ServerStatMan::load(const std::string& filename)
     if(m[S_HOST].empty() || m[S_PROTOCOL].empty()) {
       continue;
     }
-    SharedHandle<ServerStat> sstat(new ServerStat(m[S_HOST], m[S_PROTOCOL]));
+    std::shared_ptr<ServerStat> sstat(new ServerStat(m[S_HOST], m[S_PROTOCOL]));
 
     uint32_t uintval;
     if(!util::parseUIntNoThrow(uintval, m[S_DL_SPEED])) {
@@ -243,7 +243,7 @@ private:
 public:
   FindStaleServerStat(time_t timeout):timeout_(timeout) {}
 
-  bool operator()(const SharedHandle<ServerStat>& ss) const
+  bool operator()(const std::shared_ptr<ServerStat>& ss) const
   {
     return ss->getLastUpdated().difference(time_) >= timeout_;
   }
diff --git a/src/ServerStatMan.h b/src/ServerStatMan.h
index 725fdc7c..93710328 100644
--- a/src/ServerStatMan.h
+++ b/src/ServerStatMan.h
@@ -38,8 +38,8 @@
 
 #include <string>
 #include <set>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "a2time.h"
 #include "a2functional.h"
 
@@ -53,10 +53,10 @@ public:
 
   ~ServerStatMan();
 
-  SharedHandle<ServerStat> find(const std::string& hostname,
+  std::shared_ptr<ServerStat> find(const std::string& hostname,
                                 const std::string& protocol) const;
 
-  bool add(const SharedHandle<ServerStat>& serverStat);
+  bool add(const std::shared_ptr<ServerStat>& serverStat);
 
   bool load(const std::string& filename);
 
@@ -64,8 +64,8 @@ public:
 
   void removeStaleServerStat(time_t timeout);
 private:
-  typedef std::set<SharedHandle<ServerStat>,
-                   DerefLess<SharedHandle<ServerStat> > > ServerStatSet;
+  typedef std::set<std::shared_ptr<ServerStat>,
+                   DerefLess<std::shared_ptr<ServerStat> > > ServerStatSet;
   ServerStatSet serverStats_;
 };
 
diff --git a/src/SessionSerializer.cc b/src/SessionSerializer.cc
index a0a7613d..17bdef65 100644
--- a/src/SessionSerializer.cc
+++ b/src/SessionSerializer.cc
@@ -60,7 +60,7 @@
 namespace aria2 {
 
 SessionSerializer::SessionSerializer
-(const SharedHandle<RequestGroupMan>& requestGroupMan):
+(const std::shared_ptr<RequestGroupMan>& requestGroupMan):
   rgman_(requestGroupMan),
   saveError_(true),
   saveInProgress_(true),
@@ -71,7 +71,7 @@ bool SessionSerializer::save(const std::string& filename) const
   std::string tempFilename = filename;
   tempFilename += "__temp";
   {
-    SharedHandle<IOFile> fp;
+    std::shared_ptr<IOFile> fp;
 #if HAVE_ZLIB
     if (util::endsWith(filename, ".gz")) {
       fp.reset(new GZipFile(tempFilename.c_str(), IOFile::WRITE));
@@ -107,9 +107,9 @@ bool writeOptionLine(IOFile& fp, const Pref* pref,
 } // namespace
 
 namespace {
-bool writeOption(IOFile& fp, const SharedHandle<Option>& op)
+bool writeOption(IOFile& fp, const std::shared_ptr<Option>& op)
 {
-  const SharedHandle<OptionParser>& oparser = OptionParser::getInstance();
+  const std::shared_ptr<OptionParser>& oparser = OptionParser::getInstance();
   for(size_t i = 1, len = option::countOption(); i < len; ++i) {
     const Pref* pref = option::i2p(i);
     const OptionHandler* h = oparser->find(pref);
@@ -191,9 +191,9 @@ namespace {
 namespace {
 bool writeDownloadResult
 (IOFile& fp, std::set<a2_gid_t>& metainfoCache,
- const SharedHandle<DownloadResult>& dr)
+ const std::shared_ptr<DownloadResult>& dr)
 {
-  const SharedHandle<MetadataInfo>& mi = dr->metadataInfo;
+  const std::shared_ptr<MetadataInfo>& mi = dr->metadataInfo;
   if(dr->belongsTo != 0 || (mi && mi->dataOnly())) {
     return true;
   }
@@ -211,7 +211,7 @@ bool writeDownloadResult
     if(dr->fileEntries.empty()) {
       return true;
     }
-    const SharedHandle<FileEntry>& file = dr->fileEntries[0];
+    const std::shared_ptr<FileEntry>& file = dr->fileEntries[0];
     // Don't save download if there are no URIs.
     const bool hasRemaining = !file->getRemainingUris().empty();
     const bool hasSpent = !file->getSpentUris().empty();
@@ -267,7 +267,7 @@ bool SessionSerializer::save(IOFile& fp) const
   const DownloadResultList& results = rgman_->getDownloadResults();
   for(DownloadResultList::const_iterator itr = results.begin(),
         eoi = results.end(); itr != eoi; ++itr) {
-    const SharedHandle<DownloadResult>& dr = *itr;
+    const std::shared_ptr<DownloadResult>& dr = *itr;
     if(dr->result == error_code::FINISHED ||
        dr->result == error_code::REMOVED) {
       if(dr->option->getAsBool(PREF_FORCE_SAVE)) {
@@ -297,8 +297,8 @@ bool SessionSerializer::save(IOFile& fp) const
     const RequestGroupList& groups = rgman_->getRequestGroups();
     for(RequestGroupList::const_iterator itr = groups.begin(),
           eoi = groups.end(); itr != eoi; ++itr) {
-      const SharedHandle<RequestGroup>& rg = *itr;
-      SharedHandle<DownloadResult> dr = rg->createDownloadResult();
+      const std::shared_ptr<RequestGroup>& rg = *itr;
+      std::shared_ptr<DownloadResult> dr = rg->createDownloadResult();
       bool stopped = dr->result == error_code::FINISHED ||
         dr->result == error_code::REMOVED;
       if((!stopped && saveInProgress_) ||
@@ -313,8 +313,8 @@ bool SessionSerializer::save(IOFile& fp) const
     const RequestGroupList& groups = rgman_->getReservedGroups();
     for(RequestGroupList::const_iterator itr = groups.begin(),
           eoi = groups.end(); itr != eoi; ++itr) {
-      const SharedHandle<RequestGroup>& rg = *itr;
-      SharedHandle<DownloadResult> result = rg->createDownloadResult();
+      const std::shared_ptr<RequestGroup>& rg = *itr;
+      std::shared_ptr<DownloadResult> result = rg->createDownloadResult();
       if(!writeDownloadResult(fp, metainfoCache, result)) {
         return false;
       }
diff --git a/src/SessionSerializer.h b/src/SessionSerializer.h
index 15c1e6c1..a72aafdf 100644
--- a/src/SessionSerializer.h
+++ b/src/SessionSerializer.h
@@ -39,8 +39,7 @@
 
 #include <string>
 #include <iosfwd>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -49,13 +48,13 @@ class IOFile;
 
 class SessionSerializer {
 private:
-  SharedHandle<RequestGroupMan> rgman_;
+  std::shared_ptr<RequestGroupMan> rgman_;
   bool saveError_;
   bool saveInProgress_;
   bool saveWaiting_;
   bool save(IOFile& fp) const;
 public:
-  SessionSerializer(const SharedHandle<RequestGroupMan>& requestGroupMan);
+  SessionSerializer(const std::shared_ptr<RequestGroupMan>& requestGroupMan);
 
   bool save(const std::string& filename) const;
 };
diff --git a/src/ShareRatioSeedCriteria.cc b/src/ShareRatioSeedCriteria.cc
index 6fb81dbb..5c0ffc4e 100644
--- a/src/ShareRatioSeedCriteria.cc
+++ b/src/ShareRatioSeedCriteria.cc
@@ -40,7 +40,7 @@
 namespace aria2 {
 
 ShareRatioSeedCriteria::ShareRatioSeedCriteria
-(double ratio, const SharedHandle<DownloadContext>& downloadContext)
+(double ratio, const std::shared_ptr<DownloadContext>& downloadContext)
   : ratio_(ratio),
     downloadContext_(downloadContext)
 {}
@@ -62,13 +62,13 @@ bool ShareRatioSeedCriteria::evaluate()
 
 
 void ShareRatioSeedCriteria::setBtRuntime
-(const SharedHandle<BtRuntime>& btRuntime)
+(const std::shared_ptr<BtRuntime>& btRuntime)
 {
   btRuntime_ = btRuntime;
 }
 
 void ShareRatioSeedCriteria::setPieceStorage
-(const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
diff --git a/src/ShareRatioSeedCriteria.h b/src/ShareRatioSeedCriteria.h
index 9084d56d..e61e2a66 100644
--- a/src/ShareRatioSeedCriteria.h
+++ b/src/ShareRatioSeedCriteria.h
@@ -37,6 +37,8 @@
 
 #include "SeedCriteria.h"
 
+#include <memory>
+
 namespace aria2 {
 
 class DownloadContext;
@@ -46,12 +48,12 @@ class PieceStorage;
 class ShareRatioSeedCriteria : public SeedCriteria {
 private:
   double ratio_;
-  SharedHandle<DownloadContext> downloadContext_;
-  SharedHandle<BtRuntime> btRuntime_;
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<DownloadContext> downloadContext_;
+  std::shared_ptr<BtRuntime> btRuntime_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
 public:
   ShareRatioSeedCriteria
-  (double ratio, const SharedHandle<DownloadContext>& downloadContext);
+  (double ratio, const std::shared_ptr<DownloadContext>& downloadContext);
 
   virtual ~ShareRatioSeedCriteria();
 
@@ -67,9 +69,9 @@ public:
     return ratio_;
   }
 
-  void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime);
+  void setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime);
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 };
 
 } // namespace aria2
diff --git a/src/SharedHandle.cc b/src/SharedHandle.cc
deleted file mode 100644
index 9986f2f9..00000000
--- a/src/SharedHandle.cc
+++ /dev/null
@@ -1,121 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2012 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 "SharedHandle.h"
-
-namespace aria2 {
-
-SharedCount::SharedCount():refCount_(new RefCount()) {}
-
-SharedCount::SharedCount(const SharedCount& s):refCount_(s.refCount_)
-{
-  refCount_->addRefCount();
-}
-
-SharedCount::~SharedCount()
-{
-  refCount_->releaseRefCount();
-  if(refCount_->getWeakRefCount() == 0) {
-    delete refCount_;
-  }
-}
-
-bool SharedCount::reassign(const SharedCount& s)
-{
-  s.refCount_->addRefCount();
-  refCount_->releaseRefCount();
-  if(refCount_->getWeakRefCount() == 0) {
-    delete refCount_;
-    refCount_ = s.refCount_;
-    return true;
-  }
-  size_t thisCount = refCount_->getStrongRefCount();
-  refCount_ = s.refCount_;
-  return thisCount == 0;
-}
-
-void SharedCount::swap(SharedCount& r)
-{
-  std::swap(refCount_, r.refCount_);
-}
-
-WeakCount::WeakCount(const WeakRef& t):refCount_(new RefCount(t)) {}
-
-WeakCount::WeakCount(const StrongRef& t):refCount_(new RefCount()) {}
-
-WeakCount::WeakCount(const WeakCount& w):refCount_(w.refCount_)
-{
-  refCount_->addWeakRefCount();
-}
-
-WeakCount::WeakCount(const SharedCount& s):refCount_(s.refCount_)
-{
-  refCount_->addWeakRefCount();
-}
-
-WeakCount::~WeakCount()
-{
-  refCount_->releaseWeakRefCount();
-  if(refCount_->getWeakRefCount() == 0) {
-    delete refCount_;
-  }
-}
-
-bool WeakCount::reassign(const SharedCount& s)
-{
-  s.refCount_->addWeakRefCount();
-  refCount_->releaseWeakRefCount();
-  if(refCount_->getWeakRefCount() == 0) {
-    delete refCount_;
-    refCount_ = s.refCount_;
-    return true;
-  }
-  refCount_ = s.refCount_;
-  return false;
-}
-
-bool WeakCount::reassign(const WeakCount& s)
-{
-  s.refCount_->addWeakRefCount();
-  refCount_->releaseWeakRefCount();
-  if(refCount_->getWeakRefCount() == 0) {
-    delete refCount_;
-    refCount_ = s.refCount_;
-    return true;
-  }
-  refCount_ = s.refCount_;
-  return false;
-}
-
-} // namespace aria2
diff --git a/src/SharedHandle.h b/src/SharedHandle.h
deleted file mode 100644
index fa18c434..00000000
--- a/src/SharedHandle.h
+++ /dev/null
@@ -1,398 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2012 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_SHARED_HANDLE_H
-#define D_SHARED_HANDLE_H
-
-#include <cassert>
-#include <iosfwd>
-#include <algorithm>
-
-// To Use std::tr1::shared_ptr uncomment following few lines and
-// comment out SharedHandle stuff.
-//
-// #include <tr1/memory>
-// #define SharedHandle std::tr1::shared_ptr
-// #define WeakHandle std::tr1::weak_ptr
-// using std::tr1::static_pointer_cast;
-// using std::tr1::dynamic_pointer_cast;
-
-namespace aria2 {
-
-typedef struct StrongRef {} StrongRef;
-typedef struct WeakRef {} WeakRef;
-
-class RefCount {
-private:
-  size_t strongRefCount_;
-  size_t weakRefCount_;
-public:
-  RefCount():strongRefCount_(1), weakRefCount_(1) {}
-
-  RefCount(const WeakRef&):strongRefCount_(0), weakRefCount_(1) {}
-
-  inline void addRefCount() {
-    ++strongRefCount_;
-    ++weakRefCount_;
-  }
-
-  inline void addWeakRefCount() {
-    ++weakRefCount_;
-  }
-
-  inline void releaseRefCount() {
-    --strongRefCount_;
-    --weakRefCount_;
-  }
-
-  inline void releaseWeakRefCount() {
-    --weakRefCount_;
-  }
-
-  inline size_t getStrongRefCount() { return strongRefCount_; }
-
-  inline size_t getWeakRefCount() { return weakRefCount_; }
-};
-
-class WeakCount;
-
-class SharedCount {
-private:
-  friend class WeakCount;
-
-  RefCount* refCount_;
-public:
-  SharedCount();
-
-  SharedCount(const SharedCount& s);
-
-  ~SharedCount();
-
-  bool reassign(const SharedCount& s);
-
-  inline size_t getRefCount() const { return refCount_->getStrongRefCount(); }
-
-  void swap(SharedCount& r);
-};
-
-class WeakCount {
-private:
-  RefCount* refCount_;
-public:
-  WeakCount(const WeakRef& t);
-
-  WeakCount(const StrongRef& t);
-
-  WeakCount(const WeakCount& w);
-
-  WeakCount(const SharedCount& s);
-
-  ~WeakCount();
-
-  bool reassign(const SharedCount& s);
-
-  bool reassign(const WeakCount& s);
-
-  inline size_t getRefCount() const { return refCount_->getStrongRefCount(); }
-};
-
-template<typename T>
-class SharedHandle;
-
-template<typename T>
-class WeakHandle;
-
-template<typename T>
-class SharedHandle {
-private:
-  template<typename T1>
-  friend std::ostream& operator<<(std::ostream& o, const SharedHandle<T1>& sp);
-
-  template<typename T1, typename T2>
-  friend bool operator==(const SharedHandle<T1>& t1,
-                         const SharedHandle<T2>& t2);
-
-  template<typename T1, typename T2>
-  friend bool operator!=(const SharedHandle<T1>& t1,
-                         const SharedHandle<T2>& t2);
-
-  template<typename T1, typename T2>
-  friend bool operator<(const SharedHandle<T1>& t1, const SharedHandle<T2>& t2);
-
-  template<typename S> friend class SharedHandle;
-
-  template<typename S> friend class WeakHandle;
-
-  T* obj_;
-
-  SharedCount ucount_;
-
-public:
-  SharedHandle():obj_(0), ucount_() {}
-
-  explicit SharedHandle(T* obj):obj_(obj), ucount_() {}
-
-  SharedHandle(const SharedHandle& t):obj_(t.obj_), ucount_(t.ucount_) {}
-
-  template<typename S>
-  SharedHandle(const SharedHandle<S>& t):obj_(t.obj_), ucount_(t.ucount_) {}
-
-  template<typename S>
-  SharedHandle(const SharedHandle<S>& t, T* p):
-    obj_(p), ucount_(t.ucount_) {}
-
-  ~SharedHandle() {
-    if(ucount_.getRefCount() == 1) {
-      delete obj_;
-    }
-  }
-
-  SharedHandle& operator=(const SharedHandle& t) {
-    if(ucount_.reassign(t.ucount_)) {
-      delete obj_;
-    }
-    obj_ = t.obj_;
-    return *this;
-  }
-
-  template<typename S>
-  SharedHandle& operator=(const SharedHandle<S>& t) {
-    if(ucount_.reassign(t.ucount_)) {
-      delete obj_;
-    }
-    obj_ = t.obj_;
-    return *this;
-  }
-
-private:
-  typedef T* SharedHandle::*unspecified_bool_type;
-public:
-  operator unspecified_bool_type() const {
-    return obj_ == 0 ? 0 : &SharedHandle::obj_;
-  }
-
-  T* operator->() const { return obj_; }
-
-  T& operator*() const {
-    assert(obj_);
-    return *obj_;
-  }
-
-  T* get() const {
-    return obj_;
-  }
-
-  size_t getRefCount() const {
-    return ucount_.getRefCount();
-  }
-
-  void reset() {
-    *this = SharedHandle();
-  }
-
-  void reset(T* t) {
-    *this = SharedHandle(t);
-  }
-
-  void swap(SharedHandle& other)
-  {
-    std::swap(obj_, other.obj_);
-    ucount_.swap(other.ucount_);
-  }
-};
-
-template<typename T>
-void swap(SharedHandle<T>& a, SharedHandle<T>& b)
-{
-  a.swap(b);
-}
-
-template<typename T, typename S>
-SharedHandle<T>
-dynamic_pointer_cast(const SharedHandle<S>& t) {
-  if(T* p = dynamic_cast<T*>(t.get())) {
-    return SharedHandle<T>(t, p);
-  } else {
-    return SharedHandle<T>();
-  }
-}
-
-template<typename T, typename S>
-SharedHandle<T>
-static_pointer_cast(const SharedHandle<S>& t) {
-  return SharedHandle<T>(t, static_cast<T*>(t.get()));
-}
-
-// Intentionally renamed obj_ as obj_x to cause error
-template<typename T>
-std::ostream& operator<<(std::ostream& o, const SharedHandle<T>& sp) {
-  o << *sp.obj_x;
-  return o;
-}
-
-template<typename T1, typename T2>
-bool operator==(const SharedHandle<T1>& t1, const SharedHandle<T2>& t2) {
-  return *t1.obj_x == *t2.obj_;
-}
-
-template<typename T1, typename T2>
-bool operator!=(const SharedHandle<T1>& t1, const SharedHandle<T2>& t2) {
-  return *t1.obj_x != *t2.obj_;
-}
-
-template<typename T1, typename T2>
-bool operator<(const SharedHandle<T1>& t1, const SharedHandle<T2>& t2) {
-  return *t1.obj_x < *t2.obj_;
-}
-
-template<typename T>
-class WeakHandle {
-private:
-  template<typename T1>
-  friend std::ostream& operator<<(std::ostream& o, const WeakHandle<T1>& sp);
-
-  template<typename T1, typename T2>
-  friend bool operator==(const WeakHandle<T1>& t1,
-                         const WeakHandle<T2>& t2);
-
-  template<typename T1, typename T2>
-  friend bool operator!=(const WeakHandle<T1>& t1,
-                         const WeakHandle<T2>& t2);
-
-  template<typename T1, typename T2>
-  friend bool operator<(const WeakHandle<T1>& t1, const WeakHandle<T2>& t2);
-
-  template<typename S> friend class WeakHandle;
-
-  T* obj_;
-
-  WeakCount ucount_;
-
-public:
-  WeakHandle():obj_(0), ucount_(WeakRef()) {}
-
-  explicit WeakHandle(T* obj):obj_(obj), ucount_(StrongRef()) {}
-
-  WeakHandle(const WeakHandle& t):obj_(t.obj_), ucount_(t.ucount_) {}
-
-  template<typename S>
-  WeakHandle(const SharedHandle<S>& t):obj_(t.obj_), ucount_(t.ucount_) {}
-
-  template<typename S>
-  WeakHandle(const WeakHandle<S>& t, T* p):
-    obj_(p), ucount_(t.ucount_) {}
-
-  ~WeakHandle() {}
-
-  WeakHandle& operator=(const WeakHandle& t) {
-    ucount_.reassign(t.ucount_);
-    obj_ = t.obj_;
-    return *this;
-  }
-
-  template<typename S>
-  WeakHandle& operator=(const SharedHandle<S>& t) {
-    ucount_.reassign(t.ucount_);
-    obj_ = t.obj_;
-    return *this;
-  }
-
-  template<typename S>
-  WeakHandle& operator=(const WeakHandle<S>& t) {
-    ucount_.reassign(t.ucount_);
-    obj_ = t.obj_;
-    return *this;
-  }
-
-  T* operator->() { return obj_; }
-
-  T* operator->() const { return obj_; }
-
-  T& operator*() const {
-    assert(obj_);
-    return *obj_;
-  }
-
-  T* get() const {
-    if(ucount_.getRefCount() == 0 || obj_ == 0) {
-      return 0;
-    } else {
-      return obj_;
-    }
-  }
-
-  size_t getRefCount() const {
-    return ucount_.getRefCount();
-  }
-
-  void reset() {
-    *this = WeakHandle();
-  }
-};
-
-// Intentionally renamed obj_ as obj_x to cause error
-template<typename T>
-std::ostream& operator<<(std::ostream& o, const WeakHandle<T>& sp) {
-  o << *sp.obj_x;
-  return o;
-}
-
-template<typename T1, typename T2>
-bool operator==(const WeakHandle<T1>& t1, const WeakHandle<T2>& t2) {
-  return *t1.obj_x == *t2.obj_;
-}
-
-template<typename T1, typename T2>
-bool operator!=(const WeakHandle<T1>& t1, const WeakHandle<T2>& t2) {
-  return *t1.obj_x != *t2.obj_;
-}
-
-template<typename T1, typename T2>
-bool operator<(const WeakHandle<T1>& t1, const WeakHandle<T2>& t2) {
-  return *t1.obj_x < *t2.obj_;
-}
-
-template<typename T, typename S>
-WeakHandle<T>
-dynamic_pointer_cast(const WeakHandle<S>& t) {
-  if(T* p = dynamic_cast<T*>(t.get())) {
-    return WeakHandle<T>(t, p);
-  } else {
-    return WeakHandle<T>();
-  }
-}
-
-} // namespace aria2
-
-#endif // D_SHARED_HANDLE_H
diff --git a/src/Signature.h b/src/Signature.h
index 71803af0..940f89e5 100644
--- a/src/Signature.h
+++ b/src/Signature.h
@@ -39,8 +39,6 @@
 
 #include <string>
 
-#include "SharedHandle.h"
-
 namespace aria2 {
 
 class Signature {
diff --git a/src/SimpleRandomizer.cc b/src/SimpleRandomizer.cc
index 9f23ea77..ed27d586 100644
--- a/src/SimpleRandomizer.cc
+++ b/src/SimpleRandomizer.cc
@@ -42,9 +42,9 @@
 
 namespace aria2 {
 
-SharedHandle<SimpleRandomizer> SimpleRandomizer::randomizer_;
+std::shared_ptr<SimpleRandomizer> SimpleRandomizer::randomizer_;
 
-const SharedHandle<SimpleRandomizer>& SimpleRandomizer::getInstance()
+const std::shared_ptr<SimpleRandomizer>& SimpleRandomizer::getInstance()
 {
   if(!randomizer_) {
     randomizer_.reset(new SimpleRandomizer());
diff --git a/src/SimpleRandomizer.h b/src/SimpleRandomizer.h
index abbd2d46..63309fb0 100644
--- a/src/SimpleRandomizer.h
+++ b/src/SimpleRandomizer.h
@@ -37,17 +37,17 @@
 
 #include "Randomizer.h"
 
+#include <memory>
+
 #ifdef __MINGW32__
 # include <wincrypt.h>
 #endif // __MINGW32__
 
-#include "SharedHandle.h"
-
 namespace aria2 {
 
 class SimpleRandomizer : public Randomizer {
 private:
-  static SharedHandle<SimpleRandomizer> randomizer_;
+  static std::shared_ptr<SimpleRandomizer> randomizer_;
 
 #ifdef __MINGW32__
   HCRYPTPROV cryProvider_;
@@ -56,7 +56,7 @@ private:
   SimpleRandomizer();
 public:
 
-  static const SharedHandle<SimpleRandomizer>& getInstance();
+  static const std::shared_ptr<SimpleRandomizer>& getInstance();
 
   static void init();
 
diff --git a/src/SingletonHolder.h b/src/SingletonHolder.h
index dcfe9e33..323773aa 100644
--- a/src/SingletonHolder.h
+++ b/src/SingletonHolder.h
@@ -35,25 +35,27 @@
 #ifndef D_SINGLETON_HOLDER_H
 #define D_SINGLETON_HOLDER_H
 
-#include "SharedHandle.h"
+#include "common.h"
+
+#include <memory>
 
 namespace aria2 {
 
 template<typename T>
 class SingletonHolder {
 private:
-  static SharedHandle<T> instance_;
+  static std::shared_ptr<T> instance_;
 
   SingletonHolder() {}
 public:
   ~SingletonHolder() {}
 
-  static const SharedHandle<T>& instance()
+  static const std::shared_ptr<T>& instance()
   {
     return instance_;
   }
 
-  static void instance(const SharedHandle<T>& instance)
+  static void instance(const std::shared_ptr<T>& instance)
   {
     instance_ = instance;
   }
@@ -65,7 +67,7 @@ public:
 };
 
 template<typename T>
-SharedHandle<T> SingletonHolder<T>::instance_;
+std::shared_ptr<T> SingletonHolder<T>::instance_;
 
 } // namespace aria2
 
diff --git a/src/SinkStreamFilter.cc b/src/SinkStreamFilter.cc
index e7f296ea..452caae4 100644
--- a/src/SinkStreamFilter.cc
+++ b/src/SinkStreamFilter.cc
@@ -35,6 +35,7 @@
 #include "SinkStreamFilter.h"
 
 #include <cstring>
+#include <cassert>
 
 #include "BinaryStream.h"
 #include "Segment.h"
@@ -51,8 +52,8 @@ SinkStreamFilter::SinkStreamFilter(WrDiskCache* wrDiskCache, bool hashUpdate):
   bytesProcessed_(0) {}
 
 ssize_t SinkStreamFilter::transform
-(const SharedHandle<BinaryStream>& out,
- const SharedHandle<Segment>& segment,
+(const std::shared_ptr<BinaryStream>& out,
+ const std::shared_ptr<Segment>& segment,
  const unsigned char* inbuf, size_t inlen)
 {
   size_t wlen;
@@ -66,7 +67,7 @@ ssize_t SinkStreamFilter::transform
     } else {
       wlen = inlen;
     }
-    const SharedHandle<Piece>& piece = segment->getPiece();
+    const std::shared_ptr<Piece>& piece = segment->getPiece();
     if(piece->getWrDiskCacheEntry()) {
       assert(wrDiskCache_);
       // If we receive small data (e.g., 1 or 2 bytes), cache entry
diff --git a/src/SinkStreamFilter.h b/src/SinkStreamFilter.h
index 908489a9..6fe85cd6 100644
--- a/src/SinkStreamFilter.h
+++ b/src/SinkStreamFilter.h
@@ -52,8 +52,8 @@ public:
   virtual void init() {}
 
   virtual ssize_t transform
-  (const SharedHandle<BinaryStream>& out,
-   const SharedHandle<Segment>& segment,
+  (const std::shared_ptr<BinaryStream>& out,
+   const std::shared_ptr<Segment>& segment,
    const unsigned char* inbuf, size_t inlen);
 
   virtual bool finished()
@@ -75,7 +75,7 @@ public:
     return bytesProcessed_;
   }
 
-  virtual bool installDelegate(const SharedHandle<StreamFilter>& filter)
+  virtual bool installDelegate(const std::shared_ptr<StreamFilter>& filter)
   {
     return false;
   }
diff --git a/src/SocketBuffer.cc b/src/SocketBuffer.cc
index 85bc8250..eefce402 100644
--- a/src/SocketBuffer.cc
+++ b/src/SocketBuffer.cc
@@ -56,7 +56,7 @@ SocketBuffer::ByteArrayBufEntry::~ByteArrayBufEntry()
 }
 
 ssize_t SocketBuffer::ByteArrayBufEntry::send
-(const SharedHandle<SocketCore>& socket, size_t offset)
+(const std::shared_ptr<SocketCore>& socket, size_t offset)
 {
   return socket->writeData(bytes_+offset, length_-offset);
 }
@@ -84,7 +84,7 @@ SocketBuffer::StringBufEntry::StringBufEntry(const std::string& s,
 // SocketBuffer::StringBufEntry::StringBufEntry() {}
 
 ssize_t SocketBuffer::StringBufEntry::send
-(const SharedHandle<SocketCore>& socket, size_t offset)
+(const std::shared_ptr<SocketCore>& socket, size_t offset)
 {
   return socket->writeData(str_.data()+offset, str_.size()-offset);
 }
@@ -109,7 +109,7 @@ void SocketBuffer::StringBufEntry::swap(std::string& s)
   str_.swap(s);
 }
 
-SocketBuffer::SocketBuffer(const SharedHandle<SocketCore>& socket):
+SocketBuffer::SocketBuffer(const std::shared_ptr<SocketCore>& socket):
   socket_(socket), offset_(0) {}
 
 SocketBuffer::~SocketBuffer() {}
@@ -118,7 +118,7 @@ void SocketBuffer::pushBytes(unsigned char* bytes, size_t len,
                              ProgressUpdate* progressUpdate)
 {
   if(len > 0) {
-    bufq_.push_back(SharedHandle<BufEntry>
+    bufq_.push_back(std::shared_ptr<BufEntry>
                     (new ByteArrayBufEntry(bytes, len, progressUpdate)));
   }
 }
@@ -127,7 +127,7 @@ void SocketBuffer::pushStr(const std::string& data,
                            ProgressUpdate* progressUpdate)
 {
   if(data.size() > 0) {
-    bufq_.push_back(SharedHandle<BufEntry>
+    bufq_.push_back(std::shared_ptr<BufEntry>
                     (new StringBufEntry(data, progressUpdate)));
   }
 }
@@ -147,7 +147,7 @@ ssize_t SocketBuffer::send()
     iov[0].A2IOVEC_LEN = firstlen;
 
     for(num = 1; num < A2_IOV_MAX && num < bufq_.size() && amount > 0; ++num) {
-      const SharedHandle<BufEntry>& buf = bufq_[num];
+      const std::shared_ptr<BufEntry>& buf = bufq_[num];
       ssize_t len = buf->getLength();
       if(amount >= len) {
         amount -= len;
@@ -176,7 +176,7 @@ ssize_t SocketBuffer::send()
       bufq_.pop_front();
       offset_ = 0;
       for(size_t i = 1; i < num; ++i) {
-        const SharedHandle<BufEntry>& buf = bufq_[0];
+        const std::shared_ptr<BufEntry>& buf = bufq_[0];
         ssize_t len = buf->getLength();
         if(len > slen) {
           offset_ = slen;
diff --git a/src/SocketBuffer.h b/src/SocketBuffer.h
index a8b13235..67855180 100644
--- a/src/SocketBuffer.h
+++ b/src/SocketBuffer.h
@@ -39,8 +39,7 @@
 
 #include <string>
 #include <deque>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -62,7 +61,7 @@ private:
       delete progressUpdate_;
     }
     virtual ssize_t send
-    (const SharedHandle<SocketCore>& socket, size_t offset) = 0;
+    (const std::shared_ptr<SocketCore>& socket, size_t offset) = 0;
     virtual bool final(size_t offset) const = 0;
     virtual size_t getLength() const = 0;
     virtual const unsigned char* getData() const = 0;
@@ -82,7 +81,7 @@ private:
                       ProgressUpdate* progressUpdate);
     virtual ~ByteArrayBufEntry();
     virtual ssize_t send
-    (const SharedHandle<SocketCore>& socket, size_t offset);
+    (const std::shared_ptr<SocketCore>& socket, size_t offset);
     virtual bool final(size_t offset) const;
     virtual size_t getLength() const;
     virtual const unsigned char* getData() const;
@@ -97,7 +96,7 @@ private:
                    ProgressUpdate* progressUpdate);
     StringBufEntry();
     virtual ssize_t send
-    (const SharedHandle<SocketCore>& socket, size_t offset);
+    (const std::shared_ptr<SocketCore>& socket, size_t offset);
     virtual bool final(size_t offset) const;
     virtual size_t getLength() const;
     virtual const unsigned char* getData() const;
@@ -106,16 +105,16 @@ private:
     std::string str_;
   };
 
-  SharedHandle<SocketCore> socket_;
+  std::shared_ptr<SocketCore> socket_;
 
-  std::deque<SharedHandle<BufEntry> > bufq_;
+  std::deque<std::shared_ptr<BufEntry> > bufq_;
 
   // Offset of data in bufq_[0]. SocketBuffer tries to send bufq_[0],
   // but it cannot always send whole data. In this case, offset points
   // to the data to be sent in the next send() call.
   size_t offset_;
 public:
-  SocketBuffer(const SharedHandle<SocketCore>& socket);
+  SocketBuffer(const std::shared_ptr<SocketCore>& socket);
 
   ~SocketBuffer();
 
diff --git a/src/SocketCore.cc b/src/SocketCore.cc
index be8be55f..a3f24306 100644
--- a/src/SocketCore.cc
+++ b/src/SocketCore.cc
@@ -134,17 +134,17 @@ std::vector<std::pair<sockaddr_union, socklen_t> >
 SocketCore::bindAddrs_;
 
 #ifdef ENABLE_SSL
-SharedHandle<TLSContext> SocketCore::clTlsContext_;
-SharedHandle<TLSContext> SocketCore::svTlsContext_;
+std::shared_ptr<TLSContext> SocketCore::clTlsContext_;
+std::shared_ptr<TLSContext> SocketCore::svTlsContext_;
 
 void SocketCore::setClientTLSContext
-(const SharedHandle<TLSContext>& tlsContext)
+(const std::shared_ptr<TLSContext>& tlsContext)
 {
   clTlsContext_ = tlsContext;
 }
 
 void SocketCore::setServerTLSContext
-(const SharedHandle<TLSContext>& tlsContext)
+(const std::shared_ptr<TLSContext>& tlsContext)
 {
   svTlsContext_ = tlsContext;
 }
@@ -344,7 +344,7 @@ void SocketCore::beginListen()
   setNonBlockingMode();
 }
 
-SharedHandle<SocketCore> SocketCore::acceptConnection() const
+std::shared_ptr<SocketCore> SocketCore::acceptConnection() const
 {
   sockaddr_union sockaddr;
   socklen_t len = sizeof(sockaddr);
@@ -355,7 +355,7 @@ SharedHandle<SocketCore> SocketCore::acceptConnection() const
   if(fd == (sock_t) -1) {
     throw DL_ABORT_EX(fmt(EX_SOCKET_ACCEPT, errorMsg(errNum).c_str()));
   }
-  SharedHandle<SocketCore> sock(new SocketCore(fd, sockType_));
+  std::shared_ptr<SocketCore> sock(new SocketCore(fd, sockType_));
   sock->setNonBlockingMode();
   return sock;
 }
diff --git a/src/SocketCore.h b/src/SocketCore.h
index 5d27fe2e..de7065d4 100644
--- a/src/SocketCore.h
+++ b/src/SocketCore.h
@@ -41,9 +41,9 @@
 #include <cstdlib>
 #include <utility>
 #include <vector>
+#include <memory>
 
 #include "a2netcompat.h"
-#include "SharedHandle.h"
 #include "a2io.h"
 #include "a2netcompat.h"
 #include "a2time.h"
@@ -77,11 +77,11 @@ private:
 
 #if ENABLE_SSL
   // TLS context for client side
-  static SharedHandle<TLSContext> clTlsContext_;
+  static std::shared_ptr<TLSContext> clTlsContext_;
   // TLS context for server side
-  static SharedHandle<TLSContext> svTlsContext_;
+  static std::shared_ptr<TLSContext> svTlsContext_;
 
-  SharedHandle<TLSSession> tlsSession_;
+  std::shared_ptr<TLSSession> tlsSession_;
 
   /**
    * Makes this socket secure. The connection must be established
@@ -177,7 +177,7 @@ public:
    * You must call beginListen() before calling this method.
    * @return accepted socket.
    */
-  SharedHandle<SocketCore> acceptConnection() const;
+  std::shared_ptr<SocketCore> acceptConnection() const;
 
   /**
    * Connects to the server named host and the destination port is port.
@@ -307,8 +307,8 @@ public:
   bool wantWrite() const;
 
 #ifdef ENABLE_SSL
-  static void setClientTLSContext(const SharedHandle<TLSContext>& tlsContext);
-  static void setServerTLSContext(const SharedHandle<TLSContext>& tlsContext);
+  static void setClientTLSContext(const std::shared_ptr<TLSContext>& tlsContext);
+  static void setServerTLSContext(const std::shared_ptr<TLSContext>& tlsContext);
 #endif // ENABLE_SSL
 
   static void setProtocolFamily(int protocolFamily)
diff --git a/src/SocketRecvBuffer.cc b/src/SocketRecvBuffer.cc
index 2c5a1cdf..690e660d 100644
--- a/src/SocketRecvBuffer.cc
+++ b/src/SocketRecvBuffer.cc
@@ -35,6 +35,7 @@
 #include "SocketRecvBuffer.h"
 
 #include <cstring>
+#include <cassert>
 
 #include "SocketCore.h"
 #include "LogFactory.h"
@@ -42,7 +43,7 @@
 namespace aria2 {
 
 SocketRecvBuffer::SocketRecvBuffer
-(const SharedHandle<SocketCore>& socket,
+(const std::shared_ptr<SocketCore>& socket,
  size_t capacity)
   : socket_(socket),
     capacity_(capacity),
diff --git a/src/SocketRecvBuffer.h b/src/SocketRecvBuffer.h
index 693dd2c0..29c8e0dd 100644
--- a/src/SocketRecvBuffer.h
+++ b/src/SocketRecvBuffer.h
@@ -36,7 +36,8 @@
 #define D_SOCKET_RECV_BUFFER_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -45,7 +46,7 @@ class SocketCore;
 class SocketRecvBuffer {
 public:
   SocketRecvBuffer
-  (const SharedHandle<SocketCore>& socket,
+  (const std::shared_ptr<SocketCore>& socket,
    size_t capacity = 16*1024);
   ~SocketRecvBuffer();
   // Reads data from socket as much as capacity allows. Returns the
@@ -60,7 +61,7 @@ public:
     bufLen_ = 0;
   }
 
-  const SharedHandle<SocketCore>& getSocket() const
+  const std::shared_ptr<SocketCore>& getSocket() const
   {
     return socket_;
   }
@@ -82,7 +83,7 @@ public:
 
   void pushBuffer(const unsigned char* data, size_t len);
 private:
-  SharedHandle<SocketCore> socket_;
+  std::shared_ptr<SocketCore> socket_;
   size_t capacity_;
   unsigned char* buf_;
   size_t bufLen_;
diff --git a/src/StatCalc.h b/src/StatCalc.h
index 209ada99..6c0ed47a 100644
--- a/src/StatCalc.h
+++ b/src/StatCalc.h
@@ -36,7 +36,6 @@
 #define D_STAT_CALC_H
 
 #include "common.h"
-#include "SharedHandle.h"
 
 namespace aria2 {
 
diff --git a/src/StreamCheckIntegrityEntry.cc b/src/StreamCheckIntegrityEntry.cc
index aeaf5e8c..e267df73 100644
--- a/src/StreamCheckIntegrityEntry.cc
+++ b/src/StreamCheckIntegrityEntry.cc
@@ -52,12 +52,12 @@ StreamCheckIntegrityEntry::~StreamCheckIntegrityEntry() {}
 void StreamCheckIntegrityEntry::onDownloadIncomplete
 (std::vector<Command*>& commands, DownloadEngine* e)
 {
-  const SharedHandle<PieceStorage>& ps = getRequestGroup()->getPieceStorage();
+  const std::shared_ptr<PieceStorage>& ps = getRequestGroup()->getPieceStorage();
   ps->onDownloadIncomplete();
   if(getRequestGroup()->getOption()->getAsBool(PREF_HASH_CHECK_ONLY)) {
     return;
   }
-  SharedHandle<FileAllocationEntry> entry
+  std::shared_ptr<FileAllocationEntry> entry
     (new StreamFileAllocationEntry(getRequestGroup(), popNextCommand()));
   proceedFileAllocation(commands, entry, e);
 }
diff --git a/src/StreamFileAllocationEntry.cc b/src/StreamFileAllocationEntry.cc
index b93df899..9afa6f29 100644
--- a/src/StreamFileAllocationEntry.cc
+++ b/src/StreamFileAllocationEntry.cc
@@ -69,17 +69,17 @@ void StreamFileAllocationEntry::prepareForNextAction
   if(getNextCommand()) {
     // Reset download start time of PeerStat because it is started
     // before file allocation begins.
-    const SharedHandle<DownloadContext>& dctx =
+    const std::shared_ptr<DownloadContext>& dctx =
       getRequestGroup()->getDownloadContext();
-    const std::vector<SharedHandle<FileEntry> >& fileEntries =
+    const std::vector<std::shared_ptr<FileEntry> >& fileEntries =
       dctx->getFileEntries();
-    for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
+    for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i =
           fileEntries.begin(), eoi = fileEntries.end(); i != eoi; ++i) {
       const FileEntry::InFlightRequestSet& reqs =
         (*i)->getInFlightRequests();
       for(FileEntry::InFlightRequestSet::iterator j =
             reqs.begin(), eoj = reqs.end(); j != eoj; ++j) {
-        const SharedHandle<PeerStat>& peerStat = (*j)->getPeerStat();
+        const std::shared_ptr<PeerStat>& peerStat = (*j)->getPeerStat();
         if(peerStat) {
           peerStat->downloadStart();
         }
diff --git a/src/StreamFilter.cc b/src/StreamFilter.cc
index 5ab31d47..f48f182b 100644
--- a/src/StreamFilter.cc
+++ b/src/StreamFilter.cc
@@ -37,12 +37,12 @@
 namespace aria2 {
 
 StreamFilter::StreamFilter
-(const SharedHandle<StreamFilter>& delegate):
+(const std::shared_ptr<StreamFilter>& delegate):
   delegate_(delegate) {}
 
 StreamFilter::~StreamFilter() {}
 
-bool StreamFilter::installDelegate(const SharedHandle<StreamFilter>& filter)
+bool StreamFilter::installDelegate(const std::shared_ptr<StreamFilter>& filter)
 {
   if(!delegate_) {
     delegate_ = filter;
diff --git a/src/StreamFilter.h b/src/StreamFilter.h
index e5cf84f9..141e864d 100644
--- a/src/StreamFilter.h
+++ b/src/StreamFilter.h
@@ -36,8 +36,9 @@
 #define D_STREAM_FILTER_H
 
 #include "common.h"
+
 #include <string>
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -47,10 +48,10 @@ class Segment;
 // Interface for basic decoding functionality.
 class StreamFilter {
 private:
-  SharedHandle<StreamFilter> delegate_;
+  std::shared_ptr<StreamFilter> delegate_;
 public:
   StreamFilter
-  (const SharedHandle<StreamFilter>& delegate = SharedHandle<StreamFilter>());
+  (const std::shared_ptr<StreamFilter>& delegate = std::shared_ptr<StreamFilter>());
 
   virtual ~StreamFilter();
 
@@ -58,8 +59,8 @@ public:
   virtual void init() = 0;
 
   // Returns the number of bytes written to sink
-  virtual ssize_t transform(const SharedHandle<BinaryStream>& out,
-                            const SharedHandle<Segment>& segment,
+  virtual ssize_t transform(const std::shared_ptr<BinaryStream>& out,
+                            const std::shared_ptr<Segment>& segment,
                             const unsigned char* inbuf, size_t inlen) = 0;
 
   virtual bool finished() = 0;
@@ -74,9 +75,9 @@ public:
   // tranfrom() invocation.
   virtual size_t getBytesProcessed() const = 0;
 
-  virtual bool installDelegate(const SharedHandle<StreamFilter>& filter);
+  virtual bool installDelegate(const std::shared_ptr<StreamFilter>& filter);
 
-  SharedHandle<StreamFilter> getDelegate() const
+  std::shared_ptr<StreamFilter> getDelegate() const
   {
     return delegate_;
   }
diff --git a/src/TrackerWatcherCommand.cc b/src/TrackerWatcherCommand.cc
index 06d7fc3e..4c95236e 100644
--- a/src/TrackerWatcherCommand.cc
+++ b/src/TrackerWatcherCommand.cc
@@ -70,7 +70,7 @@
 
 namespace aria2 {
 
-HTTPAnnRequest::HTTPAnnRequest(const SharedHandle<RequestGroup>& rg)
+HTTPAnnRequest::HTTPAnnRequest(const std::shared_ptr<RequestGroup>& rg)
   : rg_(rg)
 {}
 
@@ -110,7 +110,7 @@ bool HTTPAnnRequest::issue(DownloadEngine* e)
 }
 
 bool HTTPAnnRequest::processResponse
-(const SharedHandle<BtAnnounce>& btAnnounce)
+(const std::shared_ptr<BtAnnounce>& btAnnounce)
 {
   try {
     std::stringstream strm;
@@ -134,7 +134,7 @@ bool HTTPAnnRequest::processResponse
   }
 }
 
-UDPAnnRequest::UDPAnnRequest(const SharedHandle<UDPTrackerRequest>& req)
+UDPAnnRequest::UDPAnnRequest(const std::shared_ptr<UDPTrackerRequest>& req)
   : req_(req)
 {}
 
@@ -173,7 +173,7 @@ bool UDPAnnRequest::issue(DownloadEngine* e)
 }
 
 bool UDPAnnRequest::processResponse
-(const SharedHandle<BtAnnounce>& btAnnounce)
+(const std::shared_ptr<BtAnnounce>& btAnnounce)
 {
   if(req_) {
     btAnnounce->processUDPTrackerResponse(req_);
@@ -264,7 +264,7 @@ void TrackerWatcherCommand::addConnection()
       break;
     }
     cuid_t ncuid = e_->newCUID();
-    SharedHandle<Peer> peer = peerStorage_->checkoutPeer(ncuid);
+    std::shared_ptr<Peer> peer = peerStorage_->checkoutPeer(ncuid);
     // sanity check
     if(!peer) {
       break;
@@ -280,10 +280,10 @@ void TrackerWatcherCommand::addConnection()
   }
 }
 
-SharedHandle<AnnRequest>
+std::shared_ptr<AnnRequest>
 TrackerWatcherCommand::createAnnounce(DownloadEngine* e)
 {
-  SharedHandle<AnnRequest> treq;
+  std::shared_ptr<AnnRequest> treq;
   while(!btAnnounce_->isAllAnnounceFailed() &&
         btAnnounce_->isAnnounceReady()) {
     std::string uri = btAnnounce_->getAnnounceUrl();
@@ -314,21 +314,21 @@ TrackerWatcherCommand::createAnnounce(DownloadEngine* e)
   return treq;
 }
 
-SharedHandle<AnnRequest>
+std::shared_ptr<AnnRequest>
 TrackerWatcherCommand::createUDPAnnRequest(const std::string& host,
                                            uint16_t port,
                                            uint16_t localPort)
 {
-  SharedHandle<UDPTrackerRequest> req =
+  std::shared_ptr<UDPTrackerRequest> req =
     btAnnounce_->createUDPTrackerRequest(host, port, localPort);
-  return SharedHandle<AnnRequest>(new UDPAnnRequest(req));
+  return std::shared_ptr<AnnRequest>(new UDPAnnRequest(req));
 }
 
 namespace {
 bool backupTrackerIsAvailable
-(const SharedHandle<DownloadContext>& context)
+(const std::shared_ptr<DownloadContext>& context)
 {
-  SharedHandle<TorrentAttribute> torrentAttrs =
+  std::shared_ptr<TorrentAttribute> torrentAttrs =
     bittorrent::getTorrentAttrs(context);
   if(torrentAttrs->announceList.size() >= 2) {
     return true;
@@ -344,13 +344,13 @@ bool backupTrackerIsAvailable
 }
 } // namespace
 
-SharedHandle<AnnRequest>
+std::shared_ptr<AnnRequest>
 TrackerWatcherCommand::createHTTPAnnRequest(const std::string& uri)
 {
   std::vector<std::string> uris;
   uris.push_back(uri);
-  SharedHandle<Option> option = util::copy(getOption());
-  SharedHandle<RequestGroup> rg(new RequestGroup(GroupId::create(), option));
+  std::shared_ptr<Option> option = util::copy(getOption());
+  std::shared_ptr<RequestGroup> rg(new RequestGroup(GroupId::create(), option));
   if(backupTrackerIsAvailable(requestGroup_->getDownloadContext())) {
     A2_LOG_DEBUG("This is multi-tracker announce.");
   } else {
@@ -369,13 +369,13 @@ TrackerWatcherCommand::createHTTPAnnRequest(const std::string& uri)
               option->get(PREF_BT_TRACKER_CONNECT_TIMEOUT));
   option->put(PREF_REUSE_URI, A2_V_FALSE);
   option->put(PREF_SELECT_LEAST_USED_HOST, A2_V_FALSE);
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(option->getAsInt(PREF_PIECE_LENGTH),
                          0,
                          "[tracker.announce]"));
   dctx->getFileEntries().front()->setUris(uris);
   rg->setDownloadContext(dctx);
-  SharedHandle<DiskWriterFactory> dwf(new ByteArrayDiskWriterFactory());
+  std::shared_ptr<DiskWriterFactory> dwf(new ByteArrayDiskWriterFactory());
   rg->setDiskWriterFactory(dwf);
   rg->setFileAllocationEnabled(false);
   rg->setPreLocalFileCheckEnabled(false);
@@ -386,34 +386,34 @@ TrackerWatcherCommand::createHTTPAnnRequest(const std::string& uri)
   dctx->setAcceptMetalink(false);
   A2_LOG_INFO(fmt("Creating tracker request group GID#%s",
                   GroupId::toHex(rg->getGID()).c_str()));
-  return SharedHandle<AnnRequest>(new HTTPAnnRequest(rg));
+  return std::shared_ptr<AnnRequest>(new HTTPAnnRequest(rg));
 }
 
 void TrackerWatcherCommand::setBtRuntime
-(const SharedHandle<BtRuntime>& btRuntime)
+(const std::shared_ptr<BtRuntime>& btRuntime)
 {
   btRuntime_ = btRuntime;
 }
 
 void TrackerWatcherCommand::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
 
 void TrackerWatcherCommand::setPieceStorage
-(const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
 
 void TrackerWatcherCommand::setBtAnnounce
-(const SharedHandle<BtAnnounce>& btAnnounce)
+(const std::shared_ptr<BtAnnounce>& btAnnounce)
 {
   btAnnounce_ = btAnnounce;
 }
 
-const SharedHandle<Option>& TrackerWatcherCommand::getOption() const
+const std::shared_ptr<Option>& TrackerWatcherCommand::getOption() const
 {
   return requestGroup_->getOption();
 }
diff --git a/src/TrackerWatcherCommand.h b/src/TrackerWatcherCommand.h
index 06b81fa1..63fa3cf9 100644
--- a/src/TrackerWatcherCommand.h
+++ b/src/TrackerWatcherCommand.h
@@ -38,8 +38,7 @@
 #include "Command.h"
 
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -66,33 +65,33 @@ public:
   // Stop this request.
   virtual void stop(DownloadEngine* e) = 0;
   // Returns true if processing tracker response is successful.
-  virtual bool processResponse(const SharedHandle<BtAnnounce>& btAnnounce) = 0;
+  virtual bool processResponse(const std::shared_ptr<BtAnnounce>& btAnnounce) = 0;
 };
 
 class HTTPAnnRequest:public AnnRequest {
 public:
-  HTTPAnnRequest(const SharedHandle<RequestGroup>& rg);
+  HTTPAnnRequest(const std::shared_ptr<RequestGroup>& rg);
   virtual ~HTTPAnnRequest();
   virtual bool stopped() const;
   virtual bool success() const;
   virtual bool issue(DownloadEngine* e);
   virtual void stop(DownloadEngine* e);
-  virtual bool processResponse(const SharedHandle<BtAnnounce>& btAnnounce);
+  virtual bool processResponse(const std::shared_ptr<BtAnnounce>& btAnnounce);
 private:
-  SharedHandle<RequestGroup> rg_;
+  std::shared_ptr<RequestGroup> rg_;
 };
 
 class UDPAnnRequest:public AnnRequest {
 public:
-  UDPAnnRequest(const SharedHandle<UDPTrackerRequest>& req);
+  UDPAnnRequest(const std::shared_ptr<UDPTrackerRequest>& req);
   virtual ~UDPAnnRequest();
   virtual bool stopped() const;
   virtual bool success() const;
   virtual bool issue(DownloadEngine* e);
   virtual void stop(DownloadEngine* e);
-  virtual bool processResponse(const SharedHandle<BtAnnounce>& btAnnounce);
+  virtual bool processResponse(const std::shared_ptr<BtAnnounce>& btAnnounce);
 private:
-  SharedHandle<UDPTrackerRequest> req_;
+  std::shared_ptr<UDPTrackerRequest> req_;
 };
 
 class TrackerWatcherCommand : public Command
@@ -102,32 +101,32 @@ private:
 
   DownloadEngine* e_;
 
-  SharedHandle<UDPTrackerClient> udpTrackerClient_;
+  std::shared_ptr<UDPTrackerClient> udpTrackerClient_;
 
-  SharedHandle<PeerStorage> peerStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
 
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
 
-  SharedHandle<BtRuntime> btRuntime_;
+  std::shared_ptr<BtRuntime> btRuntime_;
 
-  SharedHandle<BtAnnounce> btAnnounce_;
+  std::shared_ptr<BtAnnounce> btAnnounce_;
 
-  SharedHandle<AnnRequest> trackerRequest_;
+  std::shared_ptr<AnnRequest> trackerRequest_;
 
   /**
    * Returns a command for announce request. Returns 0 if no announce request
    * is needed.
    */
-  SharedHandle<AnnRequest>
+  std::shared_ptr<AnnRequest>
   createHTTPAnnRequest(const std::string& uri);
 
-  SharedHandle<AnnRequest>
+  std::shared_ptr<AnnRequest>
   createUDPAnnRequest(const std::string& host, uint16_t port,
                       uint16_t localPort);
 
   void addConnection();
 
-  const SharedHandle<Option>& getOption() const;
+  const std::shared_ptr<Option>& getOption() const;
 public:
   TrackerWatcherCommand(cuid_t cuid,
                         RequestGroup* requestGroup,
@@ -135,17 +134,17 @@ public:
 
   virtual ~TrackerWatcherCommand();
 
-  SharedHandle<AnnRequest> createAnnounce(DownloadEngine* e);
+  std::shared_ptr<AnnRequest> createAnnounce(DownloadEngine* e);
 
   virtual bool execute();
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 
-  void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime);
+  void setBtRuntime(const std::shared_ptr<BtRuntime>& btRuntime);
 
-  void setBtAnnounce(const SharedHandle<BtAnnounce>& btAnnounce);
+  void setBtAnnounce(const std::shared_ptr<BtAnnounce>& btAnnounce);
 };
 
 } // namespace aria2
diff --git a/src/UDPTrackerClient.cc b/src/UDPTrackerClient.cc
index 0ea2052e..024776f8 100644
--- a/src/UDPTrackerClient.cc
+++ b/src/UDPTrackerClient.cc
@@ -109,7 +109,7 @@ UDPTrackerClient::~UDPTrackerClient()
 
 namespace {
 struct CollectAddrPortMatch {
-  bool operator()(const SharedHandle<UDPTrackerRequest>& req) const
+  bool operator()(const std::shared_ptr<UDPTrackerRequest>& req) const
   {
     if(req->remoteAddr == remoteAddr && req->remotePort == remotePort) {
       dest.push_back(req);
@@ -118,10 +118,10 @@ struct CollectAddrPortMatch {
       return false;
     }
   }
-  std::vector<SharedHandle<UDPTrackerRequest> >& dest;
+  std::vector<std::shared_ptr<UDPTrackerRequest> >& dest;
   std::string remoteAddr;
   uint16_t remotePort;
-  CollectAddrPortMatch(std::vector<SharedHandle<UDPTrackerRequest> >& dest,
+  CollectAddrPortMatch(std::vector<std::shared_ptr<UDPTrackerRequest> >& dest,
                        const std::string& remoteAddr, uint16_t remotePort)
     : dest(dest), remoteAddr(remoteAddr), remotePort(remotePort)
   {}
@@ -140,7 +140,7 @@ int UDPTrackerClient::receiveReply
       return -1;
     }
     int32_t transactionId = bittorrent::getIntParam(data, 4);
-    SharedHandle<UDPTrackerRequest> req =
+    std::shared_ptr<UDPTrackerRequest> req =
       findInflightRequest(remoteAddr, remotePort, transactionId, true);
     if(!req) {
       logInvalidTransaction(remoteAddr, remotePort, action, transactionId);
@@ -150,13 +150,13 @@ int UDPTrackerClient::receiveReply
 
     int64_t connectionId = bittorrent::getLLIntParam(data, 8);
     A2_LOG_INFO(fmt("UDPT received CONNECT reply from %s:%u transaction_id=%u,"
-                    "connection_id=%"PRId64, remoteAddr.c_str(), remotePort,
+                    "connection_id=%" PRId64, remoteAddr.c_str(), remotePort,
                     transactionId, connectionId));
     UDPTrackerConnection c(UDPT_CST_CONNECTED, connectionId, now);
     connectionIdCache_[std::make_pair(remoteAddr, remotePort)] = c;
     // Now we have connecion ID, push requests which are waiting for
     // it.
-    std::vector<SharedHandle<UDPTrackerRequest> > reqs;
+    std::vector<std::shared_ptr<UDPTrackerRequest> > reqs;
     connectRequests_.erase(std::remove_if
                            (connectRequests_.begin(), connectRequests_.end(),
                             CollectAddrPortMatch(reqs, remoteAddr, remotePort)),
@@ -171,7 +171,7 @@ int UDPTrackerClient::receiveReply
       return - 1;
     }
     int32_t transactionId = bittorrent::getIntParam(data, 4);
-    SharedHandle<UDPTrackerRequest> req =
+    std::shared_ptr<UDPTrackerRequest> req =
       findInflightRequest(remoteAddr, remotePort, transactionId, true);
     if(!req) {
       logInvalidTransaction(remoteAddr, remotePort, action, transactionId);
@@ -197,7 +197,7 @@ int UDPTrackerClient::receiveReply
     }
 
     A2_LOG_INFO(fmt("UDPT received ANNOUNCE reply from %s:%u transaction_id=%u,"
-                    "connection_id=%"PRId64", event=%s, infohash=%s, "
+                    "connection_id=%" PRId64 ", event=%s, infohash=%s, "
                     "interval=%d, leechers=%d, "
                     "seeders=%d, num_peers=%d", remoteAddr.c_str(), remotePort,
                     transactionId, req->connectionId,
@@ -213,7 +213,7 @@ int UDPTrackerClient::receiveReply
       return -1;
     }
     int32_t transactionId = bittorrent::getIntParam(data, 4);
-    SharedHandle<UDPTrackerRequest> req =
+    std::shared_ptr<UDPTrackerRequest> req =
       findInflightRequest(remoteAddr, remotePort, transactionId, true);
     if(!req) {
       logInvalidTransaction(remoteAddr, remotePort, action, transactionId);
@@ -226,7 +226,7 @@ int UDPTrackerClient::receiveReply
     req->error = UDPT_ERR_TRACKER;
 
     A2_LOG_INFO(fmt("UDPT received ERROR reply from %s:%u transaction_id=%u,"
-                    "connection_id=%"PRId64", action=%d, error_string=%s",
+                    "connection_id=%" PRId64 ", action=%d, error_string=%s",
                     remoteAddr.c_str(),
                     remotePort, transactionId, req->connectionId, action,
                     errorString.c_str()));
@@ -255,7 +255,7 @@ ssize_t UDPTrackerClient::createRequest
     return -1;
   }
   while(!pendingRequests_.empty()) {
-    const SharedHandle<UDPTrackerRequest>& req = pendingRequests_.front();
+    const std::shared_ptr<UDPTrackerRequest>& req = pendingRequests_.front();
     if(req->action == UDPT_ACT_CONNECT) {
       ssize_t rv;
       rv = createUDPTrackerConnect(data, length, remoteAddr, remotePort, req);
@@ -265,7 +265,7 @@ ssize_t UDPTrackerClient::createRequest
                                               req->remotePort,
                                               now);
     if(!c) {
-      SharedHandle<UDPTrackerRequest> creq(new UDPTrackerRequest());
+      std::shared_ptr<UDPTrackerRequest> creq(new UDPTrackerRequest());
       creq->action = UDPT_ACT_CONNECT;
       creq->remoteAddr = req->remoteAddr;
       creq->remotePort = req->remotePort;
@@ -295,7 +295,7 @@ void UDPTrackerClient::requestSent(const Timer& now)
     A2_LOG_WARN("pendingRequests_ is empty");
     return;
   }
-  const SharedHandle<UDPTrackerRequest>& req = pendingRequests_.front();
+  const std::shared_ptr<UDPTrackerRequest>& req = pendingRequests_.front();
   switch(req->action) {
   case UDPT_ACT_CONNECT:
     A2_LOG_INFO(fmt("UDPT sent CONNECT to %s:%u transaction_id=%u",
@@ -304,7 +304,7 @@ void UDPTrackerClient::requestSent(const Timer& now)
     break;
   case UDPT_ACT_ANNOUNCE:
     A2_LOG_INFO(fmt("UDPT sent ANNOUNCE to %s:%u transaction_id=%u, "
-                    "connection_id=%"PRId64", event=%s, infohash=%s",
+                    "connection_id=%" PRId64 ", event=%s, infohash=%s",
                     req->remoteAddr.c_str(), req->remotePort,
                     req->transactionId, req->connectionId,
                     getUDPTrackerEventStr(req->event),
@@ -332,7 +332,7 @@ void UDPTrackerClient::requestFail(int error)
     A2_LOG_WARN("pendingRequests_ is empty");
     return;
   }
-  const SharedHandle<UDPTrackerRequest>& req = pendingRequests_.front();
+  const std::shared_ptr<UDPTrackerRequest>& req = pendingRequests_.front();
   switch(req->action) {
   case UDPT_ACT_CONNECT:
     A2_LOG_INFO(fmt("UDPT fail CONNECT to %s:%u transaction_id=%u",
@@ -342,7 +342,7 @@ void UDPTrackerClient::requestFail(int error)
     break;
   case UDPT_ACT_ANNOUNCE:
     A2_LOG_INFO(fmt("UDPT fail ANNOUNCE to %s:%u transaction_id=%u, "
-                    "connection_id=%"PRId64", event=%s, infohash=%s",
+                    "connection_id=%" PRId64 ", event=%s, infohash=%s",
                     req->remoteAddr.c_str(), req->remotePort,
                     req->transactionId, req->connectionId,
                     getUDPTrackerEventStr(req->event),
@@ -357,7 +357,7 @@ void UDPTrackerClient::requestFail(int error)
   pendingRequests_.pop_front();
 }
 
-void UDPTrackerClient::addRequest(const SharedHandle<UDPTrackerRequest>& req)
+void UDPTrackerClient::addRequest(const std::shared_ptr<UDPTrackerRequest>& req)
 {
   req->state = UDPT_STA_PENDING;
   req->error = UDPT_ERR_SUCCESS;
@@ -366,7 +366,7 @@ void UDPTrackerClient::addRequest(const SharedHandle<UDPTrackerRequest>& req)
 
 namespace {
 struct TimeoutCheck {
-  bool operator()(const SharedHandle<UDPTrackerRequest>& req) const
+  bool operator()(const std::shared_ptr<UDPTrackerRequest>& req) const
   {
     int t = req->dispatched.difference(now);
     if(req->failCount == 0) {
@@ -379,7 +379,7 @@ struct TimeoutCheck {
           break;
         case  UDPT_ACT_ANNOUNCE:
           A2_LOG_INFO(fmt("UDPT resend ANNOUNCE to %s:%u transaction_id=%u, "
-                          "connection_id=%"PRId64", event=%s, infohash=%s",
+                          "connection_id=%" PRId64 ", event=%s, infohash=%s",
                           req->remoteAddr.c_str(), req->remotePort,
                           req->transactionId, req->connectionId,
                           getUDPTrackerEventStr(req->event),
@@ -407,7 +407,7 @@ struct TimeoutCheck {
           break;
         case UDPT_ACT_ANNOUNCE:
           A2_LOG_INFO(fmt("UDPT timeout ANNOUNCE to %s:%u transaction_id=%u, "
-                          "connection_id=%"PRId64", event=%s, infohash=%s",
+                          "connection_id=%" PRId64 ", event=%s, infohash=%s",
                           req->remoteAddr.c_str(), req->remotePort,
                           req->transactionId, req->connectionId,
                           getUDPTrackerEventStr(req->event),
@@ -426,10 +426,10 @@ struct TimeoutCheck {
       }
     }
   }
-  std::vector<SharedHandle<UDPTrackerRequest> >& dest;
+  std::vector<std::shared_ptr<UDPTrackerRequest> >& dest;
   UDPTrackerClient* client;
   const Timer& now;
-  TimeoutCheck(std::vector<SharedHandle<UDPTrackerRequest> >& dest,
+  TimeoutCheck(std::vector<std::shared_ptr<UDPTrackerRequest> >& dest,
                UDPTrackerClient* client,
                const Timer& now)
     : dest(dest), client(client), now(now)
@@ -439,7 +439,7 @@ struct TimeoutCheck {
 
 void UDPTrackerClient::handleTimeout(const Timer& now)
 {
-  std::vector<SharedHandle<UDPTrackerRequest> > dest;
+  std::vector<std::shared_ptr<UDPTrackerRequest> > dest;
   inflightRequests_.erase(std::remove_if(inflightRequests_.begin(),
                                          inflightRequests_.end(),
                                          TimeoutCheck(dest, this, now)),
@@ -447,12 +447,12 @@ void UDPTrackerClient::handleTimeout(const Timer& now)
   pendingRequests_.insert(pendingRequests_.begin(), dest.begin(), dest.end());
 }
 
-SharedHandle<UDPTrackerRequest> UDPTrackerClient::findInflightRequest
+std::shared_ptr<UDPTrackerRequest> UDPTrackerClient::findInflightRequest
 (const std::string& remoteAddr, uint16_t remotePort, int32_t transactionId,
  bool remove)
 {
-  SharedHandle<UDPTrackerRequest> res;
-  for(std::deque<SharedHandle<UDPTrackerRequest> >::iterator i =
+  std::shared_ptr<UDPTrackerRequest> res;
+  for(std::deque<std::shared_ptr<UDPTrackerRequest> >::iterator i =
         inflightRequests_.begin(), eoi = inflightRequests_.end(); i != eoi;
       ++i) {
     if((*i)->remoteAddr == remoteAddr && (*i)->remotePort == remotePort &&
@@ -487,7 +487,7 @@ UDPTrackerConnection* UDPTrackerClient::getConnectionId
 
 namespace {
 struct FailConnectDelete {
-  bool operator()(const SharedHandle<UDPTrackerRequest>& req) const
+  bool operator()(const std::shared_ptr<UDPTrackerRequest>& req) const
   {
     if(req->action == UDPT_ACT_ANNOUNCE &&
        req->remoteAddr == remoteAddr && req->remotePort == remotePort) {
@@ -548,7 +548,7 @@ void UDPTrackerClient::decreaseWatchers()
 ssize_t createUDPTrackerConnect
 (unsigned char* data, size_t length,
  std::string& remoteAddr, uint16_t& remotePort,
- const SharedHandle<UDPTrackerRequest>& req)
+ const std::shared_ptr<UDPTrackerRequest>& req)
 {
   assert(length >= 16);
   remoteAddr = req->remoteAddr;
@@ -562,7 +562,7 @@ ssize_t createUDPTrackerConnect
 ssize_t createUDPTrackerAnnounce
 (unsigned char* data, size_t length,
  std::string& remoteAddr, uint16_t& remotePort,
- const SharedHandle<UDPTrackerRequest>& req)
+ const std::shared_ptr<UDPTrackerRequest>& req)
 {
   assert(length >= 100);
   remoteAddr = req->remoteAddr;
diff --git a/src/UDPTrackerClient.h b/src/UDPTrackerClient.h
index f2a8df82..fccac0bd 100644
--- a/src/UDPTrackerClient.h
+++ b/src/UDPTrackerClient.h
@@ -40,8 +40,8 @@
 #include <string>
 #include <deque>
 #include <map>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimerA2.h"
 
 namespace aria2 {
@@ -96,22 +96,22 @@ public:
   // successfully sent. The |error| should indicate error situation.
   void requestFail(int error);
 
-  void addRequest(const SharedHandle<UDPTrackerRequest>& req);
+  void addRequest(const std::shared_ptr<UDPTrackerRequest>& req);
 
   // Handles timeout for inflight requests.
   void handleTimeout(const Timer& now);
 
-  const std::deque<SharedHandle<UDPTrackerRequest> >&
+  const std::deque<std::shared_ptr<UDPTrackerRequest> >&
   getPendingRequests() const
   {
     return pendingRequests_;
   }
-  const std::deque<SharedHandle<UDPTrackerRequest> >&
+  const std::deque<std::shared_ptr<UDPTrackerRequest> >&
   getConnectRequests() const
   {
     return connectRequests_;
   }
-  const std::deque<SharedHandle<UDPTrackerRequest> >&
+  const std::deque<std::shared_ptr<UDPTrackerRequest> >&
   getInflightRequests() const
   {
     return inflightRequests_;
@@ -139,7 +139,7 @@ public:
   void failConnect(const std::string& remoteAddr, uint16_t remotePort,
                    int error);
 private:
-  SharedHandle<UDPTrackerRequest> findInflightRequest
+  std::shared_ptr<UDPTrackerRequest> findInflightRequest
   (const std::string& remoteAddr, uint16_t remotePort, int32_t transactionId,
    bool remove);
 
@@ -148,19 +148,19 @@ private:
 
   std::map<std::pair<std::string, uint16_t>,
            UDPTrackerConnection> connectionIdCache_;
-  std::deque<SharedHandle<UDPTrackerRequest> > inflightRequests_;
-  std::deque<SharedHandle<UDPTrackerRequest> > pendingRequests_;
-  std::deque<SharedHandle<UDPTrackerRequest> > connectRequests_;
+  std::deque<std::shared_ptr<UDPTrackerRequest> > inflightRequests_;
+  std::deque<std::shared_ptr<UDPTrackerRequest> > pendingRequests_;
+  std::deque<std::shared_ptr<UDPTrackerRequest> > connectRequests_;
   int numWatchers_;
 };
 
 ssize_t createUDPTrackerConnect
 (unsigned char* data, size_t length, std::string& remoteAddr,
- uint16_t& remotePort, const SharedHandle<UDPTrackerRequest>& req);
+ uint16_t& remotePort, const std::shared_ptr<UDPTrackerRequest>& req);
 
 ssize_t createUDPTrackerAnnounce
 (unsigned char* data, size_t length, std::string& remoteAddr,
- uint16_t& remotePort, const SharedHandle<UDPTrackerRequest>& req);
+ uint16_t& remotePort, const std::shared_ptr<UDPTrackerRequest>& req);
 
 const char* getUDPTrackerActionStr(int action);
 
diff --git a/src/UDPTrackerRequest.h b/src/UDPTrackerRequest.h
index 8012b182..b7e9ab23 100644
--- a/src/UDPTrackerRequest.h
+++ b/src/UDPTrackerRequest.h
@@ -39,8 +39,8 @@
 
 #include <string>
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TimerA2.h"
 
 namespace aria2 {
@@ -103,7 +103,7 @@ struct UDPTrackerRequest {
   int error;
   Timer dispatched;
   int failCount;
-  SharedHandle<UDPTrackerReply> reply;
+  std::shared_ptr<UDPTrackerReply> reply;
   UDPTrackerRequest();
 };
 
diff --git a/src/UTMetadataDataExtensionMessage.cc b/src/UTMetadataDataExtensionMessage.cc
index 72ac6964..88d78d71 100644
--- a/src/UTMetadataDataExtensionMessage.cc
+++ b/src/UTMetadataDataExtensionMessage.cc
@@ -115,13 +115,13 @@ void UTMetadataDataExtensionMessage::setData(const std::string& data)
 }
 
 void UTMetadataDataExtensionMessage::setPieceStorage
-(const SharedHandle<PieceStorage>& pieceStorage)
+(const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
 
 void UTMetadataDataExtensionMessage::setDownloadContext
-(const SharedHandle<DownloadContext>& dctx)
+(const std::shared_ptr<DownloadContext>& dctx)
 {
   dctx_ = dctx;
 }
diff --git a/src/UTMetadataDataExtensionMessage.h b/src/UTMetadataDataExtensionMessage.h
index 75720412..ca8ff59e 100644
--- a/src/UTMetadataDataExtensionMessage.h
+++ b/src/UTMetadataDataExtensionMessage.h
@@ -36,7 +36,8 @@
 #define D_UT_METADATA_DATA_EXTENSION_MESSAGE_H
 
 #include "UTMetadataExtensionMessage.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -50,9 +51,9 @@ private:
 
   std::string data_;
 
-  SharedHandle<DownloadContext> dctx_;
+  std::shared_ptr<DownloadContext> dctx_;
 
-  SharedHandle<PieceStorage> pieceStorage_;
+  std::shared_ptr<PieceStorage> pieceStorage_;
 
   UTMetadataRequestTracker* tracker_;
 public:
@@ -89,14 +90,14 @@ public:
     return data_;
   }
 
-  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+  void setPieceStorage(const std::shared_ptr<PieceStorage>& pieceStorage);
 
   void setUTMetadataRequestTracker(UTMetadataRequestTracker* tracker)
   {
     tracker_ = tracker;
   }
 
-  void setDownloadContext(const SharedHandle<DownloadContext>& dctx);
+  void setDownloadContext(const std::shared_ptr<DownloadContext>& dctx);
 };
 
 } // namespace aria2
diff --git a/src/UTMetadataPostDownloadHandler.cc b/src/UTMetadataPostDownloadHandler.cc
index 0557a1b1..da9f1a4a 100644
--- a/src/UTMetadataPostDownloadHandler.cc
+++ b/src/UTMetadataPostDownloadHandler.cc
@@ -56,10 +56,10 @@ namespace aria2 {
 bool UTMetadataPostDownloadHandler::Criteria::match
 (const RequestGroup* requestGroup) const
 {
-  const SharedHandle<DownloadContext>& dctx =
+  const std::shared_ptr<DownloadContext>& dctx =
     requestGroup->getDownloadContext();
   if(dctx->hasAttribute(CTX_ATTR_BT)) {
-    SharedHandle<TorrentAttribute> attrs = bittorrent::getTorrentAttrs(dctx);
+    std::shared_ptr<TorrentAttribute> attrs = bittorrent::getTorrentAttrs(dctx);
     if(attrs->metadata.empty()) {
       return true;
     }
@@ -69,15 +69,15 @@ bool UTMetadataPostDownloadHandler::Criteria::match
 
 UTMetadataPostDownloadHandler::UTMetadataPostDownloadHandler()
 {
-  SharedHandle<Criteria> cri(new Criteria());
+  std::shared_ptr<Criteria> cri(new Criteria());
   setCriteria(cri);
 }
 
 void UTMetadataPostDownloadHandler::getNextRequestGroups
-(std::vector<SharedHandle<RequestGroup> >& groups, RequestGroup* requestGroup)
+(std::vector<std::shared_ptr<RequestGroup> >& groups, RequestGroup* requestGroup)
 {
-  const SharedHandle<DownloadContext>& dctx =requestGroup->getDownloadContext();
-  SharedHandle<TorrentAttribute> attrs = bittorrent::getTorrentAttrs(dctx);
+  const std::shared_ptr<DownloadContext>& dctx =requestGroup->getDownloadContext();
+  std::shared_ptr<TorrentAttribute> attrs = bittorrent::getTorrentAttrs(dctx);
   std::string metadata =
     util::toString(requestGroup->getPieceStorage()->getDiskAdaptor());
   std::string torrent = bittorrent::metadata2Torrent(metadata, attrs);
@@ -93,7 +93,7 @@ void UTMetadataPostDownloadHandler::getNextRequestGroups
     }
   }
   if(!requestGroup->getOption()->getAsBool(PREF_BT_METADATA_ONLY)) {
-    std::vector<SharedHandle<RequestGroup> > newRgs;
+    std::vector<std::shared_ptr<RequestGroup> > newRgs;
     // Don't adjust announce URI because it has been done when
     // RequestGroup is created with magnet URI.
     createRequestGroupForBitTorrent(newRgs, requestGroup->getOption(),
diff --git a/src/UTMetadataPostDownloadHandler.h b/src/UTMetadataPostDownloadHandler.h
index 19364304..54c40c9e 100644
--- a/src/UTMetadataPostDownloadHandler.h
+++ b/src/UTMetadataPostDownloadHandler.h
@@ -52,7 +52,7 @@ public:
   UTMetadataPostDownloadHandler();
 
   virtual void
-  getNextRequestGroups(std::vector<SharedHandle<RequestGroup> >& groups,
+  getNextRequestGroups(std::vector<std::shared_ptr<RequestGroup> >& groups,
                        RequestGroup* requestGroup);
 };
 
diff --git a/src/UTMetadataRequestExtensionMessage.cc b/src/UTMetadataRequestExtensionMessage.cc
index a12d088a..f4444123 100644
--- a/src/UTMetadataRequestExtensionMessage.cc
+++ b/src/UTMetadataRequestExtensionMessage.cc
@@ -76,17 +76,17 @@ std::string UTMetadataRequestExtensionMessage::toString() const
 
 void UTMetadataRequestExtensionMessage::doReceivedAction()
 {
-  SharedHandle<TorrentAttribute> attrs = bittorrent::getTorrentAttrs(dctx_);
+  std::shared_ptr<TorrentAttribute> attrs = bittorrent::getTorrentAttrs(dctx_);
   uint8_t id = peer_->getExtensionMessageID
     (ExtensionMessageRegistry::UT_METADATA);
   if(attrs->metadata.empty()) {
-    SharedHandle<UTMetadataRejectExtensionMessage> m
+    std::shared_ptr<UTMetadataRejectExtensionMessage> m
       (new UTMetadataRejectExtensionMessage(id));
     m->setIndex(getIndex());
-    SharedHandle<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
+    std::shared_ptr<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
     dispatcher_->addMessageToQueue(msg);
   }else if(getIndex()*METADATA_PIECE_SIZE < attrs->metadataSize) {
-    SharedHandle<UTMetadataDataExtensionMessage> m
+    std::shared_ptr<UTMetadataDataExtensionMessage> m
       (new UTMetadataDataExtensionMessage(id));
     m->setIndex(getIndex());
     m->setTotalSize(attrs->metadataSize);
@@ -97,7 +97,7 @@ void UTMetadataRequestExtensionMessage::doReceivedAction()
       attrs->metadata.begin()+(getIndex()+1)*METADATA_PIECE_SIZE:
       attrs->metadata.end();
     m->setData(begin, end);
-    SharedHandle<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
+    std::shared_ptr<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
     dispatcher_->addMessageToQueue(msg);
   } else {
     throw DL_ABORT_EX
@@ -107,12 +107,12 @@ void UTMetadataRequestExtensionMessage::doReceivedAction()
 }
 
 void UTMetadataRequestExtensionMessage::setDownloadContext
-(const SharedHandle<DownloadContext>& dctx)
+(const std::shared_ptr<DownloadContext>& dctx)
 {
   dctx_ = dctx;
 }
 
-void UTMetadataRequestExtensionMessage::setPeer(const SharedHandle<Peer>& peer)
+void UTMetadataRequestExtensionMessage::setPeer(const std::shared_ptr<Peer>& peer)
 {
   peer_ = peer;
 }
diff --git a/src/UTMetadataRequestExtensionMessage.h b/src/UTMetadataRequestExtensionMessage.h
index 5c5e3f7f..f7896f13 100644
--- a/src/UTMetadataRequestExtensionMessage.h
+++ b/src/UTMetadataRequestExtensionMessage.h
@@ -36,7 +36,8 @@
 #define D_UT_METADATA_REQUEST_EXTENSION_MESSAGE_H
 
 #include "UTMetadataExtensionMessage.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -47,9 +48,9 @@ class Peer;
 
 class UTMetadataRequestExtensionMessage:public UTMetadataExtensionMessage {
 private:
-  SharedHandle<DownloadContext> dctx_;
+  std::shared_ptr<DownloadContext> dctx_;
 
-  SharedHandle<Peer> peer_;
+  std::shared_ptr<Peer> peer_;
 
   BtMessageDispatcher* dispatcher_;
 
@@ -65,7 +66,7 @@ public:
 
   virtual void doReceivedAction();
 
-  void setDownloadContext(const SharedHandle<DownloadContext>& dctx);
+  void setDownloadContext(const std::shared_ptr<DownloadContext>& dctx);
 
   void setBtMessageDispatcher(BtMessageDispatcher* disp)
   {
@@ -77,7 +78,7 @@ public:
     messageFactory_ = factory;
   }
 
-  void setPeer(const SharedHandle<Peer>& peer);
+  void setPeer(const std::shared_ptr<Peer>& peer);
 };
 
 } // namespace aria2
diff --git a/src/UTMetadataRequestFactory.cc b/src/UTMetadataRequestFactory.cc
index cfe26998..06e13dad 100644
--- a/src/UTMetadataRequestFactory.cc
+++ b/src/UTMetadataRequestFactory.cc
@@ -56,12 +56,12 @@ UTMetadataRequestFactory::UTMetadataRequestFactory()
 {}
 
 void UTMetadataRequestFactory::create
-(std::vector<SharedHandle<BtMessage> >& msgs, size_t num,
- const SharedHandle<PieceStorage>& pieceStorage)
+(std::vector<std::shared_ptr<BtMessage> >& msgs, size_t num,
+ const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   while(num) {
     std::vector<size_t> metadataRequests = tracker_->getAllTrackedIndex();
-    SharedHandle<Piece> p =
+    std::shared_ptr<Piece> p =
       pieceStorage->getMissingPiece(peer_, metadataRequests, cuid_);
     if(!p) {
       A2_LOG_DEBUG("No ut_metadata piece is available to download.");
@@ -70,7 +70,7 @@ void UTMetadataRequestFactory::create
     --num;
     A2_LOG_DEBUG(fmt("Creating ut_metadata request index=%lu",
                      static_cast<unsigned long>(p->getIndex())));
-    SharedHandle<UTMetadataRequestExtensionMessage> m
+    std::shared_ptr<UTMetadataRequestExtensionMessage> m
       (new UTMetadataRequestExtensionMessage
        (peer_->getExtensionMessageID(ExtensionMessageRegistry::UT_METADATA)));
     m->setIndex(p->getIndex());
@@ -79,7 +79,7 @@ void UTMetadataRequestFactory::create
     m->setBtMessageFactory(messageFactory_);
     m->setPeer(peer_);
 
-    SharedHandle<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
+    std::shared_ptr<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
     msgs.push_back(msg);
     tracker_->add(p->getIndex());
   }
diff --git a/src/UTMetadataRequestFactory.h b/src/UTMetadataRequestFactory.h
index 7af3e8da..8839cfe4 100644
--- a/src/UTMetadataRequestFactory.h
+++ b/src/UTMetadataRequestFactory.h
@@ -38,8 +38,8 @@
 #include "common.h"
 
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "Command.h"
 
 namespace aria2 {
@@ -54,9 +54,9 @@ class BtMessage;
 
 class UTMetadataRequestFactory {
 private:
-  SharedHandle<DownloadContext> dctx_;
+  std::shared_ptr<DownloadContext> dctx_;
 
-  SharedHandle<Peer> peer_;
+  std::shared_ptr<Peer> peer_;
 
   BtMessageDispatcher* dispatcher_;
 
@@ -69,10 +69,10 @@ public:
 
   // Creates at most num of ut_metadata request message and appends
   // them to msgs. pieceStorage is used to identify missing piece.
-  void create(std::vector<SharedHandle<BtMessage> >& msgs, size_t num,
-              const SharedHandle<PieceStorage>& pieceStorage);
+  void create(std::vector<std::shared_ptr<BtMessage> >& msgs, size_t num,
+              const std::shared_ptr<PieceStorage>& pieceStorage);
 
-  void setDownloadContext(const SharedHandle<DownloadContext>& dctx)
+  void setDownloadContext(const std::shared_ptr<DownloadContext>& dctx)
   {
     dctx_ = dctx;
   }
@@ -87,7 +87,7 @@ public:
     messageFactory_ = factory;
   }
 
-  void setPeer(const SharedHandle<Peer>& peer)
+  void setPeer(const std::shared_ptr<Peer>& peer)
   {
     peer_ = peer;
   }
diff --git a/src/UTPexExtensionMessage.cc b/src/UTPexExtensionMessage.cc
index a5245772..4def037f 100644
--- a/src/UTPexExtensionMessage.cc
+++ b/src/UTPexExtensionMessage.cc
@@ -96,13 +96,13 @@ std::string UTPexExtensionMessage::getPayload()
 std::pair<std::pair<std::string, std::string>,
           std::pair<std::string, std::string> >
 UTPexExtensionMessage::createCompactPeerListAndFlag
-(const std::vector<SharedHandle<Peer> >& peers)
+(const std::vector<std::shared_ptr<Peer> >& peers)
 {
   std::string addrstring;
   std::string flagstring;
   std::string addrstring6;
   std::string flagstring6;
-  for(std::vector<SharedHandle<Peer> >::const_iterator itr = peers.begin(),
+  for(std::vector<std::shared_ptr<Peer> >::const_iterator itr = peers.begin(),
         eoi = peers.end(); itr != eoi; ++itr) {
     unsigned char compact[COMPACT_LEN_IPV6];
     int compactlen = bittorrent::packcompact
@@ -132,7 +132,7 @@ void UTPexExtensionMessage::doReceivedAction()
   peerStorage_->addPeer(droppedPeers_);
 }
 
-bool UTPexExtensionMessage::addFreshPeer(const SharedHandle<Peer>& peer)
+bool UTPexExtensionMessage::addFreshPeer(const std::shared_ptr<Peer>& peer)
 {
   if(!peer->isIncomingPeer() &&
      peer->getFirstContactTime().difference(global::wallclock()) < interval_) {
@@ -148,7 +148,7 @@ bool UTPexExtensionMessage::freshPeersAreFull() const
   return freshPeers_.size() >= maxFreshPeer_;
 }
 
-bool UTPexExtensionMessage::addDroppedPeer(const SharedHandle<Peer>& peer)
+bool UTPexExtensionMessage::addDroppedPeer(const std::shared_ptr<Peer>& peer)
 {
   if(!peer->isIncomingPeer() &&
      peer->getDropStartTime().difference(global::wallclock()) < interval_) {
@@ -175,7 +175,7 @@ void UTPexExtensionMessage::setMaxDroppedPeer(size_t maxDroppedPeer)
 }
 
 void UTPexExtensionMessage::setPeerStorage
-(const SharedHandle<PeerStorage>& peerStorage)
+(const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
@@ -190,7 +190,7 @@ UTPexExtensionMessage::create(const unsigned char* data, size_t len)
   }
   UTPexExtensionMessage* msg(new UTPexExtensionMessage(*data));
 
-  SharedHandle<ValueBase> decoded = bencode2::decode(data+1, len - 1);
+  std::shared_ptr<ValueBase> decoded = bencode2::decode(data+1, len - 1);
   const Dict* dict = downcast<Dict>(decoded);
   if(dict) {
     const String* added = downcast<String>(dict->get("added"));
diff --git a/src/UTPexExtensionMessage.h b/src/UTPexExtensionMessage.h
index 3f273bf6..8ae7bee2 100644
--- a/src/UTPexExtensionMessage.h
+++ b/src/UTPexExtensionMessage.h
@@ -39,9 +39,9 @@
 
 #include <utility>
 #include <vector>
+#include <memory>
 
 #include "a2time.h"
-#include "SharedHandle.h"
 
 namespace aria2 {
 
@@ -52,11 +52,11 @@ class UTPexExtensionMessage:public ExtensionMessage {
 private:
   uint8_t extensionMessageID_;
 
-  std::vector<SharedHandle<Peer> > freshPeers_;
+  std::vector<std::shared_ptr<Peer> > freshPeers_;
 
-  std::vector<SharedHandle<Peer> > droppedPeers_;
+  std::vector<std::shared_ptr<Peer> > droppedPeers_;
 
-  SharedHandle<PeerStorage> peerStorage_;
+  std::shared_ptr<PeerStorage> peerStorage_;
 
   time_t interval_;
 
@@ -66,7 +66,7 @@ private:
 
   std::pair<std::pair<std::string, std::string>,
             std::pair<std::string, std::string> >
-  createCompactPeerListAndFlag(const std::vector<SharedHandle<Peer> >& peers);
+  createCompactPeerListAndFlag(const std::vector<std::shared_ptr<Peer> >& peers);
 
 public:
   UTPexExtensionMessage(uint8_t extensionMessageID);
@@ -91,25 +91,25 @@ public:
 
   virtual void doReceivedAction();
 
-  bool addFreshPeer(const SharedHandle<Peer>& peer);
+  bool addFreshPeer(const std::shared_ptr<Peer>& peer);
 
-  const std::vector<SharedHandle<Peer> >& getFreshPeers() const
+  const std::vector<std::shared_ptr<Peer> >& getFreshPeers() const
   {
     return freshPeers_;
   }
 
   bool freshPeersAreFull() const;
 
-  bool addDroppedPeer(const SharedHandle<Peer>& peer);
+  bool addDroppedPeer(const std::shared_ptr<Peer>& peer);
 
-  const std::vector<SharedHandle<Peer> >& getDroppedPeers() const
+  const std::vector<std::shared_ptr<Peer> >& getDroppedPeers() const
   {
     return droppedPeers_;
   }
 
   bool droppedPeersAreFull() const;
 
-  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+  void setPeerStorage(const std::shared_ptr<PeerStorage>& peerStorage);
 
   static UTPexExtensionMessage*
   create(const unsigned char* data, size_t len);
diff --git a/src/UnionSeedCriteria.cc b/src/UnionSeedCriteria.cc
index d2785b71..f06eca0b 100644
--- a/src/UnionSeedCriteria.cc
+++ b/src/UnionSeedCriteria.cc
@@ -41,7 +41,7 @@ namespace aria2 {
 namespace {
 class Reset {
 public:
-  void operator()(const SharedHandle<SeedCriteria>& cri)
+  void operator()(const std::shared_ptr<SeedCriteria>& cri)
   {
     cri->reset();
   }
@@ -51,7 +51,7 @@ public:
 namespace {
 class Eval {
 public:
-  bool operator()(const SharedHandle<SeedCriteria>& cri)
+  bool operator()(const std::shared_ptr<SeedCriteria>& cri)
   {
     return cri->evaluate();
   }
@@ -68,12 +68,12 @@ void UnionSeedCriteria::reset()
 
 bool UnionSeedCriteria::evaluate()
 {
-  std::vector<SharedHandle<SeedCriteria> >::iterator itr =
+  std::vector<std::shared_ptr<SeedCriteria> >::iterator itr =
     std::find_if(criterion_.begin(), criterion_.end(), Eval());
   return itr != criterion_.end();
 }
 
-void UnionSeedCriteria::addSeedCriteria(const SharedHandle<SeedCriteria>& cri)
+void UnionSeedCriteria::addSeedCriteria(const std::shared_ptr<SeedCriteria>& cri)
 {
   criterion_.push_back(cri);
 }
diff --git a/src/UnionSeedCriteria.h b/src/UnionSeedCriteria.h
index 44e2ee3b..1e50e913 100644
--- a/src/UnionSeedCriteria.h
+++ b/src/UnionSeedCriteria.h
@@ -38,12 +38,13 @@
 #include "SeedCriteria.h"
 
 #include <vector>
+#include <memory>
 
 namespace aria2 {
 
 class UnionSeedCriteria : public SeedCriteria {
 private:
-  std::vector<SharedHandle<SeedCriteria> > criterion_;
+  std::vector<std::shared_ptr<SeedCriteria> > criterion_;
 public:
   UnionSeedCriteria();
   virtual ~UnionSeedCriteria();
@@ -52,9 +53,9 @@ public:
 
   virtual bool evaluate();
 
-  void addSeedCriteria(const SharedHandle<SeedCriteria>& cri);
+  void addSeedCriteria(const std::shared_ptr<SeedCriteria>& cri);
 
-  const std::vector<SharedHandle<SeedCriteria> >& getSeedCriterion() const
+  const std::vector<std::shared_ptr<SeedCriteria> >& getSeedCriterion() const
   {
     return criterion_;
   }
diff --git a/src/UnknownLengthPieceStorage.cc b/src/UnknownLengthPieceStorage.cc
index 43f26b23..d111723c 100644
--- a/src/UnknownLengthPieceStorage.cc
+++ b/src/UnknownLengthPieceStorage.cc
@@ -47,7 +47,7 @@
 namespace aria2 {
 
 UnknownLengthPieceStorage::UnknownLengthPieceStorage
-(const SharedHandle<DownloadContext>& downloadContext)
+(const std::shared_ptr<DownloadContext>& downloadContext)
   : downloadContext_(downloadContext),
   diskWriterFactory_(new DefaultDiskWriterFactory()),
   totalLength_(0),
@@ -62,7 +62,7 @@ void UnknownLengthPieceStorage::initStorage()
   directDiskAdaptor->setFileEntries(downloadContext_->getFileEntries().begin(),
                                     downloadContext_->getFileEntries().end());
 
-  SharedHandle<DiskWriter> writer =
+  std::shared_ptr<DiskWriter> writer =
     diskWriterFactory_->newDiskWriter(directDiskAdaptor->getFilePath());
   directDiskAdaptor->setDiskWriter(writer);
 
@@ -71,24 +71,24 @@ void UnknownLengthPieceStorage::initStorage()
 
 #ifdef ENABLE_BITTORRENT
 
-bool UnknownLengthPieceStorage::hasMissingPiece(const SharedHandle<Peer>& peer)
+bool UnknownLengthPieceStorage::hasMissingPiece(const std::shared_ptr<Peer>& peer)
 {
   abort();
 }
 
 void UnknownLengthPieceStorage::getMissingPiece
-(std::vector<SharedHandle<Piece> >& pieces,
+(std::vector<std::shared_ptr<Piece> >& pieces,
  size_t minMissingBlocks,
- const SharedHandle<Peer>& peer,
+ const std::shared_ptr<Peer>& peer,
  cuid_t cuid)
 {
   abort();
 }
 
 void UnknownLengthPieceStorage::getMissingPiece
-(std::vector<SharedHandle<Piece> >& pieces,
+(std::vector<std::shared_ptr<Piece> >& pieces,
  size_t minMissingBlocks,
- const SharedHandle<Peer>& peer,
+ const std::shared_ptr<Peer>& peer,
  const std::vector<size_t>& excludedIndexes,
  cuid_t cuid)
 {
@@ -96,33 +96,33 @@ void UnknownLengthPieceStorage::getMissingPiece
 }
 
 void UnknownLengthPieceStorage::getMissingFastPiece
-(std::vector<SharedHandle<Piece> >& pieces,
+(std::vector<std::shared_ptr<Piece> >& pieces,
  size_t minMissingBlocks,
- const SharedHandle<Peer>& peer,
+ const std::shared_ptr<Peer>& peer,
  cuid_t cuid)
 {
   abort();
 }
 
 void UnknownLengthPieceStorage::getMissingFastPiece
-(std::vector<SharedHandle<Piece> >& pieces,
+(std::vector<std::shared_ptr<Piece> >& pieces,
  size_t minMissingBlocks,
- const SharedHandle<Peer>& peer,
+ const std::shared_ptr<Peer>& peer,
  const std::vector<size_t>& excludedIndexes,
  cuid_t cuid)
 {
   abort();
 }
 
-SharedHandle<Piece> UnknownLengthPieceStorage::getMissingPiece
-(const SharedHandle<Peer>& peer,
+std::shared_ptr<Piece> UnknownLengthPieceStorage::getMissingPiece
+(const std::shared_ptr<Peer>& peer,
  cuid_t cuid)
 {
   abort();
 }
 
-SharedHandle<Piece> UnknownLengthPieceStorage::getMissingPiece
-(const SharedHandle<Peer>& peer,
+std::shared_ptr<Piece> UnknownLengthPieceStorage::getMissingPiece
+(const std::shared_ptr<Peer>& peer,
  const std::vector<size_t>& excludedIndexes,
  cuid_t cuid)
 {
@@ -135,48 +135,48 @@ bool UnknownLengthPieceStorage::hasMissingUnusedPiece()
   abort();
 }
 
-SharedHandle<Piece> UnknownLengthPieceStorage::getMissingPiece
+std::shared_ptr<Piece> UnknownLengthPieceStorage::getMissingPiece
 (size_t minSplitSize,
  const unsigned char* ignoreBitfield,
  size_t length,
  cuid_t cuid)
 {
   if(downloadFinished_) {
-    return SharedHandle<Piece>();
+    return std::shared_ptr<Piece>();
   }
   if(!piece_) {
     piece_.reset(new Piece());
     return piece_;
   } else {
-    return SharedHandle<Piece>();
+    return std::shared_ptr<Piece>();
   }
 }
 
-SharedHandle<Piece> UnknownLengthPieceStorage::getMissingPiece
+std::shared_ptr<Piece> UnknownLengthPieceStorage::getMissingPiece
 (size_t index,
  cuid_t cuid)
 {
   if(index == 0) {
     return getMissingPiece(0, 0, 0, cuid);
   } else {
-    return SharedHandle<Piece>();
+    return std::shared_ptr<Piece>();
   }
 }
 
-SharedHandle<Piece> UnknownLengthPieceStorage::getPiece(size_t index)
+std::shared_ptr<Piece> UnknownLengthPieceStorage::getPiece(size_t index)
 {
   if(index == 0) {
     if(!piece_) {
-      return SharedHandle<Piece>(new Piece());
+      return std::shared_ptr<Piece>(new Piece());
     } else {
       return piece_;
     }
   } else {
-    return SharedHandle<Piece>();
+    return std::shared_ptr<Piece>();
   }
 }
 
-void UnknownLengthPieceStorage::completePiece(const SharedHandle<Piece>& piece)
+void UnknownLengthPieceStorage::completePiece(const std::shared_ptr<Piece>& piece)
 {
   if(*piece_ == *piece) {
     downloadFinished_ = true;
@@ -187,7 +187,7 @@ void UnknownLengthPieceStorage::completePiece(const SharedHandle<Piece>& piece)
 }
 
 void UnknownLengthPieceStorage::cancelPiece
-(const SharedHandle<Piece>& piece,
+(const std::shared_ptr<Piece>& piece,
  cuid_t cuid)
 {
   if(*piece_ == *piece) {
@@ -213,7 +213,7 @@ bool UnknownLengthPieceStorage::isPieceUsed(size_t index)
   }
 }
 
-SharedHandle<DiskAdaptor> UnknownLengthPieceStorage::getDiskAdaptor()
+std::shared_ptr<DiskAdaptor> UnknownLengthPieceStorage::getDiskAdaptor()
 {
   return diskAdaptor_;
 }
@@ -249,11 +249,11 @@ void UnknownLengthPieceStorage::markPieceMissing(size_t index)
 }
 
 void UnknownLengthPieceStorage::getInFlightPieces
-(std::vector<SharedHandle<Piece> >& pieces)
+(std::vector<std::shared_ptr<Piece> >& pieces)
 {}
 
 void UnknownLengthPieceStorage::setDiskWriterFactory
-(const SharedHandle<DiskWriterFactory>& diskWriterFactory)
+(const std::shared_ptr<DiskWriterFactory>& diskWriterFactory)
 {
   diskWriterFactory_ = diskWriterFactory;
 }
diff --git a/src/UnknownLengthPieceStorage.h b/src/UnknownLengthPieceStorage.h
index 68caa8fd..c7d232ed 100644
--- a/src/UnknownLengthPieceStorage.h
+++ b/src/UnknownLengthPieceStorage.h
@@ -46,19 +46,19 @@ class DirectDiskAdaptor;
 
 class UnknownLengthPieceStorage:public PieceStorage {
 private:
-  SharedHandle<DownloadContext> downloadContext_;
+  std::shared_ptr<DownloadContext> downloadContext_;
 
-  SharedHandle<DirectDiskAdaptor> diskAdaptor_;
+  std::shared_ptr<DirectDiskAdaptor> diskAdaptor_;
 
-  SharedHandle<DiskWriterFactory> diskWriterFactory_;
+  std::shared_ptr<DiskWriterFactory> diskWriterFactory_;
 
   int64_t totalLength_;
 
   bool downloadFinished_;
 
-  SharedHandle<Piece> piece_;
+  std::shared_ptr<Piece> piece_;
 public:
-  UnknownLengthPieceStorage(const SharedHandle<DownloadContext>& downloadContext);
+  UnknownLengthPieceStorage(const std::shared_ptr<DownloadContext>& downloadContext);
 
   virtual ~UnknownLengthPieceStorage();
 
@@ -68,40 +68,40 @@ public:
    * Returns true if the peer has a piece that localhost doesn't have.
    * Otherwise returns false.
    */
-  virtual bool hasMissingPiece(const SharedHandle<Peer>& peer);
+  virtual bool hasMissingPiece(const std::shared_ptr<Peer>& peer);
 
   virtual void getMissingPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    cuid_t cuid);
 
   virtual void getMissingPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
    cuid_t cuid);
 
   virtual void getMissingFastPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    cuid_t cuid);
 
   virtual void getMissingFastPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
    cuid_t cuid);
 
-  virtual SharedHandle<Piece> getMissingPiece
-  (const SharedHandle<Peer>& peer,
+  virtual std::shared_ptr<Piece> getMissingPiece
+  (const std::shared_ptr<Peer>& peer,
    cuid_t cuid);
 
-  virtual SharedHandle<Piece> getMissingPiece
-  (const SharedHandle<Peer>& peer,
+  virtual std::shared_ptr<Piece> getMissingPiece
+  (const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
    cuid_t cuid);
 #endif // ENABLE_BITTORRENT
@@ -111,7 +111,7 @@ public:
   /**
    * Returns a missing piece if available. Otherwise returns 0;
    */
-  virtual SharedHandle<Piece> getMissingPiece
+  virtual std::shared_ptr<Piece> getMissingPiece
   (size_t minSplitSize,
    const unsigned char* ignoreBitfield,
    size_t length,
@@ -123,23 +123,23 @@ public:
    * then returns 0.
    * Also returns 0 if any of missing piece is not available.
    */
-  virtual SharedHandle<Piece> getMissingPiece(size_t index, cuid_t cuid);
+  virtual std::shared_ptr<Piece> getMissingPiece(size_t index, cuid_t cuid);
 
   /**
    * Returns the piece denoted by index.
    * No status of the piece is changed in this method.
    */
-  virtual SharedHandle<Piece> getPiece(size_t index);
+  virtual std::shared_ptr<Piece> getPiece(size_t index);
 
   /**
    * Tells that the download of the specfied piece completes.
    */
-  virtual void completePiece(const SharedHandle<Piece>& piece);
+  virtual void completePiece(const std::shared_ptr<Piece>& piece);
 
   /**
    * Tells that the download of the specified piece is canceled.
    */
-  virtual void cancelPiece(const SharedHandle<Piece>& piece, cuid_t cuid);
+  virtual void cancelPiece(const std::shared_ptr<Piece>& piece, cuid_t cuid);
 
   /**
    * Returns true if the specified piece is already downloaded.
@@ -226,7 +226,7 @@ public:
 
   virtual void setEndGamePieceNum(size_t num) {}
 
-  virtual SharedHandle<DiskAdaptor> getDiskAdaptor();
+  virtual std::shared_ptr<DiskAdaptor> getDiskAdaptor();
 
   virtual WrDiskCache* getWrDiskCache() { return 0; }
 
@@ -269,14 +269,14 @@ public:
    * class.
    */
   virtual void addInFlightPiece
-  (const std::vector<SharedHandle<Piece> >& pieces) {}
+  (const std::vector<std::shared_ptr<Piece> >& pieces) {}
 
   virtual size_t countInFlightPiece()
   {
     return 0;
   }
 
-  virtual void getInFlightPieces(std::vector<SharedHandle<Piece> >& pieces);
+  virtual void getInFlightPieces(std::vector<std::shared_ptr<Piece> >& pieces);
 
   virtual void addPieceStats(size_t index) {}
 
@@ -292,7 +292,7 @@ public:
 
   virtual size_t getNextUsedIndex(size_t index) { return 0; }
 
-  void setDiskWriterFactory(const SharedHandle<DiskWriterFactory>& diskWriterFactory);
+  void setDiskWriterFactory(const std::shared_ptr<DiskWriterFactory>& diskWriterFactory);
 
   virtual void onDownloadIncomplete() {}
 };
diff --git a/src/UnknownOptionException.cc b/src/UnknownOptionException.cc
index 6eaec2b5..33e87fd8 100644
--- a/src/UnknownOptionException.cc
+++ b/src/UnknownOptionException.cc
@@ -59,9 +59,9 @@ UnknownOptionException::UnknownOptionException
 
 UnknownOptionException::~UnknownOptionException() throw() {}
 
-SharedHandle<Exception> UnknownOptionException::copy() const
+std::shared_ptr<Exception> UnknownOptionException::copy() const
 {
-  SharedHandle<Exception> e(new UnknownOptionException(*this));
+  std::shared_ptr<Exception> e(new UnknownOptionException(*this));
   return e;
 }
 
diff --git a/src/UnknownOptionException.h b/src/UnknownOptionException.h
index 0371b724..b6dd2e88 100644
--- a/src/UnknownOptionException.h
+++ b/src/UnknownOptionException.h
@@ -42,7 +42,7 @@ class UnknownOptionException:public RecoverableException {
 private:
   std::string unknownOption_;
 protected:
-  virtual SharedHandle<Exception> copy() const;
+  virtual std::shared_ptr<Exception> copy() const;
 public:
   UnknownOptionException(const char* file, int line,
                          const std::string& unknownOption);
diff --git a/src/UriListParser.cc b/src/UriListParser.cc
index 3261beb9..f0e41a4d 100644
--- a/src/UriListParser.cc
+++ b/src/UriListParser.cc
@@ -63,7 +63,7 @@ UriListParser::~UriListParser() {}
 
 void UriListParser::parseNext(std::vector<std::string>& uris, Option& op)
 {
-  const SharedHandle<OptionParser>& optparser = OptionParser::getInstance();
+  const std::shared_ptr<OptionParser>& optparser = OptionParser::getInstance();
   while(1) {
     if(!line_.empty() && line_[0] != '#') {
       util::split(line_.begin(), line_.end(), std::back_inserter(uris),
diff --git a/src/UriListParser.h b/src/UriListParser.h
index ce456120..c340ad41 100644
--- a/src/UriListParser.h
+++ b/src/UriListParser.h
@@ -40,16 +40,16 @@
 #include <string>
 #include <deque>
 #include <iosfwd>
+#include <memory>
 
 #include "Option.h"
 #include "IOFile.h"
-#include "SharedHandle.h"
 
 namespace aria2 {
 
 class UriListParser {
 private:
-  SharedHandle<IOFile> fp_;
+  std::shared_ptr<IOFile> fp_;
 
   std::string line_;
 public:
diff --git a/src/ValueBase.cc b/src/ValueBase.cc
index 7165f886..b8c4e6db 100644
--- a/src/ValueBase.cc
+++ b/src/ValueBase.cc
@@ -36,7 +36,7 @@
 
 namespace aria2 {
 
-const SharedHandle<ValueBase> ValueBase::none;
+const std::shared_ptr<ValueBase> ValueBase::none;
 
 String::String(const ValueType& string):str_(string) {}
 
@@ -61,14 +61,14 @@ const unsigned char* String::uc() const
   return reinterpret_cast<const unsigned char*>(str_.data());
 }
 
-SharedHandle<String> String::g(const ValueType& string)
+std::shared_ptr<String> String::g(const ValueType& string)
 {
-  return SharedHandle<String>(new String(string));
+  return std::shared_ptr<String>(new String(string));
 }
 
-SharedHandle<String> String::g(const unsigned char* data, size_t length)
+std::shared_ptr<String> String::g(const unsigned char* data, size_t length)
 {
-  return SharedHandle<String>(new String(data, length));
+  return std::shared_ptr<String>(new String(data, length));
 }
 
 void String::accept(ValueBaseVisitor& v) const
@@ -87,9 +87,9 @@ Integer::ValueType Integer::i() const
   return integer_;
 }
 
-SharedHandle<Integer> Integer::g(ValueType integer)
+std::shared_ptr<Integer> Integer::g(ValueType integer)
 {
-  return SharedHandle<Integer>(new Integer(integer));
+  return std::shared_ptr<Integer>(new Integer(integer));
 }
 
 void Integer::accept(ValueBaseVisitor& v) const
@@ -97,15 +97,15 @@ void Integer::accept(ValueBaseVisitor& v) const
   v.visit(*this);
 }
 
-const SharedHandle<Bool> Bool::trueValue_(new Bool(true));
-const SharedHandle<Bool> Bool::falseValue_(new Bool(false));
+const std::shared_ptr<Bool> Bool::trueValue_(new Bool(true));
+const std::shared_ptr<Bool> Bool::falseValue_(new Bool(false));
 
-SharedHandle<Bool> Bool::gTrue()
+std::shared_ptr<Bool> Bool::gTrue()
 {
   return trueValue_;
 }
 
-SharedHandle<Bool> Bool::gFalse()
+std::shared_ptr<Bool> Bool::gFalse()
 {
   return falseValue_;
 }
@@ -122,9 +122,9 @@ void Bool::accept(ValueBaseVisitor& v) const
 
 Bool::Bool(bool val):val_(val) {}
 
-const SharedHandle<Null> Null::nullValue_(new Null());
+const std::shared_ptr<Null> Null::nullValue_(new Null());
 
-SharedHandle<Null> Null::g()
+std::shared_ptr<Null> Null::g()
 {
   return nullValue_;
 }
@@ -140,17 +140,17 @@ List::List() {}
 
 List::~List() {}
 
-const SharedHandle<ValueBase>& List::get(size_t index) const
+const std::shared_ptr<ValueBase>& List::get(size_t index) const
 {
   return list_[index];
 }
 
-void List::set(size_t index, const SharedHandle<ValueBase>& v)
+void List::set(size_t index, const std::shared_ptr<ValueBase>& v)
 {
   list_[index] = v;
 }
 
-void List::append(const SharedHandle<ValueBase>& v)
+void List::append(const std::shared_ptr<ValueBase>& v)
 {
   list_.push_back(v);
 }
@@ -160,13 +160,13 @@ void List::append(const String::ValueType& string)
   list_.push_back(String::g(string));
 }
 
-List& List::operator<<(const SharedHandle<ValueBase>& v)
+List& List::operator<<(const std::shared_ptr<ValueBase>& v)
 {
   list_.push_back(v);
   return *this;
 }
 
-const SharedHandle<ValueBase>& List::operator[](size_t index) const
+const std::shared_ptr<ValueBase>& List::operator[](size_t index) const
 {
   return list_[index];
 }
@@ -201,9 +201,9 @@ bool List::empty() const
   return list_.empty();
 }
 
-SharedHandle<List> List::g()
+std::shared_ptr<List> List::g()
 {
-  return SharedHandle<List>(new List());
+  return std::shared_ptr<List>(new List());
 }
 
 void List::accept(ValueBaseVisitor& v) const
@@ -215,7 +215,7 @@ Dict::Dict() {}
 
 Dict::~Dict() {}
 
-void Dict::put(const std::string& key, const SharedHandle<ValueBase>& vlb)
+void Dict::put(const std::string& key, const std::shared_ptr<ValueBase>& vlb)
 {
   ValueType::value_type p = std::make_pair(key, vlb);
   std::pair<ValueType::iterator, bool> r = dict_.insert(p);
@@ -229,7 +229,7 @@ void Dict::put(const std::string& key, const String::ValueType& string)
   put(key, String::g(string));
 }
 
-const SharedHandle<ValueBase>& Dict::get(const std::string& key) const
+const std::shared_ptr<ValueBase>& Dict::get(const std::string& key) const
 {
   ValueType::const_iterator itr = dict_.find(key);
   if(itr == dict_.end()) {
@@ -239,7 +239,7 @@ const SharedHandle<ValueBase>& Dict::get(const std::string& key) const
   }
 }
 
-SharedHandle<ValueBase>& Dict::get(const std::string& key)
+std::shared_ptr<ValueBase>& Dict::get(const std::string& key)
 {
   ValueType::iterator itr = dict_.find(key);
   if(itr == dict_.end()) {
@@ -249,12 +249,12 @@ SharedHandle<ValueBase>& Dict::get(const std::string& key)
   }
 }
 
-SharedHandle<ValueBase>& Dict::operator[](const std::string& key)
+std::shared_ptr<ValueBase>& Dict::operator[](const std::string& key)
 {
   return get(key);
 }
 
-const SharedHandle<ValueBase>& Dict::operator[](const std::string& key) const
+const std::shared_ptr<ValueBase>& Dict::operator[](const std::string& key) const
 {
   return get(key);
 }
@@ -299,9 +299,9 @@ bool Dict::empty() const
   return dict_.empty();
 }
 
-SharedHandle<Dict> Dict::g()
+std::shared_ptr<Dict> Dict::g()
 {
-  return SharedHandle<Dict>(new Dict());
+  return std::shared_ptr<Dict>(new Dict());
 }
 void Dict::accept(ValueBaseVisitor& v) const
 {
diff --git a/src/ValueBase.h b/src/ValueBase.h
index f3d90af0..c7986acf 100644
--- a/src/ValueBase.h
+++ b/src/ValueBase.h
@@ -40,8 +40,7 @@
 #include <string>
 #include <vector>
 #include <map>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -53,7 +52,7 @@ public:
 
   virtual void accept(ValueBaseVisitor& visitor) const = 0;
 
-  static const SharedHandle<ValueBase> none;
+  static const std::shared_ptr<ValueBase> none;
 };
 
 class String;
@@ -105,14 +104,14 @@ public:
   // Use s().size() to get length.
   const unsigned char* uc() const;
 
-  static SharedHandle<String> g(const ValueType& string);
+  static std::shared_ptr<String> g(const ValueType& string);
 
-  static SharedHandle<String> g(const unsigned char* data, size_t length);
+  static std::shared_ptr<String> g(const unsigned char* data, size_t length);
 
   template<typename InputIterator>
-  static SharedHandle<String> g(InputIterator first, InputIterator last)
+  static std::shared_ptr<String> g(InputIterator first, InputIterator last)
   {
-    return SharedHandle<String>(new String(first, last));
+    return std::shared_ptr<String>(new String(first, last));
   }
 
   virtual void accept(ValueBaseVisitor& visitor) const;
@@ -137,7 +136,7 @@ public:
   // Returns Integer.
   ValueType i() const;
 
-  static SharedHandle<Integer> g(ValueType integer);
+  static std::shared_ptr<Integer> g(ValueType integer);
 
   virtual void accept(ValueBaseVisitor& visitor) const;
 private:
@@ -146,8 +145,8 @@ private:
 
 class Bool:public ValueBase {
 public:
-  static SharedHandle<Bool> gTrue();
-  static SharedHandle<Bool> gFalse();
+  static std::shared_ptr<Bool> gTrue();
+  static std::shared_ptr<Bool> gFalse();
   bool val() const;
   virtual void accept(ValueBaseVisitor& visitor) const;
 private:
@@ -156,25 +155,25 @@ private:
   Bool(const Bool&);
   Bool& operator=(const Bool&);
   bool val_;
-  static const SharedHandle<Bool> trueValue_;
-  static const SharedHandle<Bool> falseValue_;
+  static const std::shared_ptr<Bool> trueValue_;
+  static const std::shared_ptr<Bool> falseValue_;
 };
 
 class Null:public ValueBase {
 public:
-  static SharedHandle<Null> g();
+  static std::shared_ptr<Null> g();
   virtual void accept(ValueBaseVisitor& visitor) const;
 private:
   Null();
   // Don't allow copying
   Null(const Null&);
   Null& operator=(const Null&);
-  static const SharedHandle<Null> nullValue_;
+  static const std::shared_ptr<Null> nullValue_;
 };
 
 class List:public ValueBase {
 public:
-  typedef std::vector<SharedHandle<ValueBase> > ValueType;
+  typedef std::vector<std::shared_ptr<ValueBase> > ValueType;
 
   List();
 
@@ -185,22 +184,22 @@ public:
   List& operator=(const List&);
 
   // Appends given v to list.
-  void append(const SharedHandle<ValueBase>& v);
+  void append(const std::shared_ptr<ValueBase>& v);
 
   // Appeding string is so common that we provide shortcut function.
   void append(const String::ValueType& string);
 
   // Alias for append()
-  List& operator<<(const SharedHandle<ValueBase>& v);
+  List& operator<<(const std::shared_ptr<ValueBase>& v);
 
   // Returns the object at given index.
-  const SharedHandle<ValueBase>& get(size_t index) const;
+  const std::shared_ptr<ValueBase>& get(size_t index) const;
 
   // Set the object at given index.
-  void set(size_t index, const SharedHandle<ValueBase>& v);
+  void set(size_t index, const std::shared_ptr<ValueBase>& v);
 
   // Returns the const reference of the object at the given index.
-  const SharedHandle<ValueBase>& operator[](size_t index) const;
+  const std::shared_ptr<ValueBase>& operator[](size_t index) const;
 
   // Returns a read/write iterator that points to the first object in
   // list.
@@ -224,7 +223,7 @@ public:
   // Returns true if size of list is 0.
   bool empty() const;
 
-  static SharedHandle<List> g();
+  static std::shared_ptr<List> g();
 
   virtual void accept(ValueBaseVisitor& visitor) const;
 private:
@@ -233,7 +232,7 @@ private:
 
 class Dict:public ValueBase {
 public:
-  typedef std::map<std::string, SharedHandle<ValueBase> > ValueType;
+  typedef std::map<std::string, std::shared_ptr<ValueBase> > ValueType;
 
   Dict();
 
@@ -243,24 +242,24 @@ public:
   Dict(const Dict&);
   Dict& operator=(const Dict&);
 
-  void put(const std::string& key, const SharedHandle<ValueBase>& vlb);
+  void put(const std::string& key, const std::shared_ptr<ValueBase>& vlb);
 
   // Putting string is so common that we provide shortcut function.
   void put(const std::string& key, const String::ValueType& string);
 
-  const SharedHandle<ValueBase>& get(const std::string& key) const;
+  const std::shared_ptr<ValueBase>& get(const std::string& key) const;
 
-  SharedHandle<ValueBase>& get(const std::string& key);
+  std::shared_ptr<ValueBase>& get(const std::string& key);
 
   // Returns the reference to object associated with given key.  If
   // the key is not found, new pair with that key is created using
   // default values, which is then returned. In other words, this is
   // the same behavior of std::map's operator[].
-  SharedHandle<ValueBase>& operator[](const std::string& key);
+  std::shared_ptr<ValueBase>& operator[](const std::string& key);
 
   // Returns the const reference to ojbect associated with given key.
   // If the key is not found, ValueBase::none is returned.
-  const SharedHandle<ValueBase>& operator[](const std::string& key) const;
+  const std::shared_ptr<ValueBase>& operator[](const std::string& key) const;
 
   // Returns true if the given key is found in dict.
   bool containsKey(const std::string& key) const;
@@ -290,7 +289,7 @@ public:
   // Returns true if size of Dict is 0.
   bool empty() const;
 
-  static SharedHandle<Dict> g();
+  static std::shared_ptr<Dict> g();
 
   virtual void accept(ValueBaseVisitor& visitor) const;
 private:
diff --git a/src/ValueBaseDiskWriter.h b/src/ValueBaseDiskWriter.h
index 3f326c96..5c26ca83 100644
--- a/src/ValueBaseDiskWriter.h
+++ b/src/ValueBaseDiskWriter.h
@@ -92,7 +92,7 @@ public:
     return parser_.parseFinal(0, 0);
   }
 
-  SharedHandle<ValueBase> getResult() const
+  std::shared_ptr<ValueBase> getResult() const
   {
     return psm_.getResult();
   }
diff --git a/src/ValueBaseStructParserStateImpl.cc b/src/ValueBaseStructParserStateImpl.cc
index 4d62426e..8118675b 100644
--- a/src/ValueBaseStructParserStateImpl.cc
+++ b/src/ValueBaseStructParserStateImpl.cc
@@ -33,6 +33,9 @@
  */
 /* copyright --> */
 #include "ValueBaseStructParserStateImpl.h"
+
+#include <cassert>
+
 #include "ValueBaseStructParserStateMachine.h"
 #include "ValueBase.h"
 
diff --git a/src/ValueBaseStructParserStateMachine.cc b/src/ValueBaseStructParserStateMachine.cc
index 04d1033c..4f63ed14 100644
--- a/src/ValueBaseStructParserStateMachine.cc
+++ b/src/ValueBaseStructParserStateMachine.cc
@@ -65,7 +65,7 @@ NullValueBaseStructParserState* nullState =
   new NullValueBaseStructParserState();
 } // namespace
 
-const SharedHandle<ValueBase>&
+const std::shared_ptr<ValueBase>&
 ValueBaseStructParserStateMachine::noResult()
 {
   return ValueBase::none;
@@ -102,7 +102,7 @@ void ValueBaseStructParserStateMachine::endElement(int elementType)
   stateStack_.pop();
 }
 
-SharedHandle<ValueBase>
+std::shared_ptr<ValueBase>
 ValueBaseStructParserStateMachine::getResult() const
 {
   return getCurrentFrameValue();
@@ -159,12 +159,12 @@ void ValueBaseStructParserStateMachine::pushFrame()
 }
 
 void ValueBaseStructParserStateMachine::setCurrentFrameValue
-(const SharedHandle<ValueBase>& value)
+(const std::shared_ptr<ValueBase>& value)
 {
   ctrl_->setCurrentFrameValue(value);
 }
 
-const SharedHandle<ValueBase>&
+const std::shared_ptr<ValueBase>&
 ValueBaseStructParserStateMachine::getCurrentFrameValue() const
 {
   return ctrl_->getCurrentFrameValue();
diff --git a/src/ValueBaseStructParserStateMachine.h b/src/ValueBaseStructParserStateMachine.h
index 5b5efa56..a0f0e6a5 100644
--- a/src/ValueBaseStructParserStateMachine.h
+++ b/src/ValueBaseStructParserStateMachine.h
@@ -39,8 +39,7 @@
 
 #include <string>
 #include <stack>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -56,8 +55,8 @@ class ValueBaseStructParserState;
 // value holder.
 class ValueBaseStructParserStateMachine : public StructParserStateMachine {
 public:
-  typedef SharedHandle<ValueBase> ResultType;
-  static const SharedHandle<ValueBase>& noResult();
+  typedef std::shared_ptr<ValueBase> ResultType;
+  static const std::shared_ptr<ValueBase>& noResult();
 
   struct NumberData {
     int64_t number;
@@ -81,7 +80,7 @@ public:
   virtual void numberCallback(int64_t number, int frac, int exp);
   virtual void boolCallback(bool bval);
 
-  SharedHandle<ValueBase> getResult() const;
+  std::shared_ptr<ValueBase> getResult() const;
 
   virtual void reset();
 
@@ -92,8 +91,8 @@ public:
   void popArrayFrame();
   void popDictFrame();
   void pushFrame();
-  void setCurrentFrameValue(const SharedHandle<ValueBase>& value);
-  const SharedHandle<ValueBase>& getCurrentFrameValue() const;
+  void setCurrentFrameValue(const std::shared_ptr<ValueBase>& value);
+  const std::shared_ptr<ValueBase>& getCurrentFrameValue() const;
   void setCurrentFrameName(const std::string& name);
 
   void pushDictState();
diff --git a/src/WebSocketInteractionCommand.cc b/src/WebSocketInteractionCommand.cc
index a21db84d..a1eaf3af 100644
--- a/src/WebSocketInteractionCommand.cc
+++ b/src/WebSocketInteractionCommand.cc
@@ -50,9 +50,9 @@ namespace rpc {
 
 WebSocketInteractionCommand::WebSocketInteractionCommand
 (cuid_t cuid,
- const SharedHandle<WebSocketSession>& wsSession,
+ const std::shared_ptr<WebSocketSession>& wsSession,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& socket)
+ const std::shared_ptr<SocketCore>& socket)
  : Command(cuid),
    e_(e),
    socket_(socket),
@@ -92,10 +92,10 @@ bool WebSocketInteractionCommand::execute()
   }
   if(wsSession_->onReadEvent() == -1 || wsSession_->onWriteEvent() == -1) {
     if(wsSession_->closeSent() || wsSession_->closeReceived()) {
-      A2_LOG_INFO(fmt("CUID#%"PRId64" - WebSocket session terminated.",
+      A2_LOG_INFO(fmt("CUID#%" PRId64 " - WebSocket session terminated.",
                       getCuid()));
     } else {
-      A2_LOG_INFO(fmt("CUID#%"PRId64" - WebSocket session terminated"
+      A2_LOG_INFO(fmt("CUID#%" PRId64 " - WebSocket session terminated"
                       " (Possibly due to EOF).", getCuid()));
     }
     return true;
diff --git a/src/WebSocketInteractionCommand.h b/src/WebSocketInteractionCommand.h
index c27bf90e..4b1acf73 100644
--- a/src/WebSocketInteractionCommand.h
+++ b/src/WebSocketInteractionCommand.h
@@ -36,7 +36,8 @@
 #define D_WEB_SOCKET_INTERACTION_COMMAND_H
 
 #include "Command.h"
-#include "SharedHandle.h"
+
+#include <memory>
 
 namespace aria2 {
 
@@ -50,14 +51,14 @@ class WebSocketSession;
 class WebSocketInteractionCommand : public Command {
 private:
   DownloadEngine* e_;
-  SharedHandle<SocketCore> socket_;
+  std::shared_ptr<SocketCore> socket_;
   bool writeCheck_;
-  SharedHandle<WebSocketSession> wsSession_;
+  std::shared_ptr<WebSocketSession> wsSession_;
 public:
   WebSocketInteractionCommand(cuid_t cuid,
-                              const SharedHandle<WebSocketSession>& wsSession,
+                              const std::shared_ptr<WebSocketSession>& wsSession,
                               DownloadEngine* e,
-                              const SharedHandle<SocketCore>& socket);
+                              const std::shared_ptr<SocketCore>& socket);
 
   virtual ~WebSocketInteractionCommand();
 
diff --git a/src/WebSocketResponseCommand.cc b/src/WebSocketResponseCommand.cc
index ba6add52..245c14d7 100644
--- a/src/WebSocketResponseCommand.cc
+++ b/src/WebSocketResponseCommand.cc
@@ -45,9 +45,9 @@ namespace rpc {
 
 WebSocketResponseCommand::WebSocketResponseCommand
 (cuid_t cuid,
- const SharedHandle<HttpServer>& httpServer,
+ const std::shared_ptr<HttpServer>& httpServer,
  DownloadEngine* e,
- const SharedHandle<SocketCore>& socket)
+ const std::shared_ptr<SocketCore>& socket)
   : AbstractHttpServerResponseCommand(cuid, httpServer, e, socket)
 {}
 
@@ -55,10 +55,10 @@ WebSocketResponseCommand::~WebSocketResponseCommand()
 {}
 
 void WebSocketResponseCommand::afterSend
-(const SharedHandle<HttpServer>& httpServer,
+(const std::shared_ptr<HttpServer>& httpServer,
  DownloadEngine* e)
 {
-  SharedHandle<WebSocketSession> wsSession
+  std::shared_ptr<WebSocketSession> wsSession
     (new WebSocketSession(httpServer->getSocket(), getDownloadEngine()));
   WebSocketInteractionCommand* command =
     new WebSocketInteractionCommand(getCuid(), wsSession, e,
diff --git a/src/WebSocketResponseCommand.h b/src/WebSocketResponseCommand.h
index 1c3cc642..b570a5d0 100644
--- a/src/WebSocketResponseCommand.h
+++ b/src/WebSocketResponseCommand.h
@@ -43,13 +43,13 @@ namespace rpc {
 
 class WebSocketResponseCommand : public AbstractHttpServerResponseCommand {
 protected:
-  virtual void afterSend(const SharedHandle<HttpServer>& httpServer,
+  virtual void afterSend(const std::shared_ptr<HttpServer>& httpServer,
                          DownloadEngine* e);
 public:
   WebSocketResponseCommand(cuid_t cuid,
-                           const SharedHandle<HttpServer>& httpServer,
+                           const std::shared_ptr<HttpServer>& httpServer,
                            DownloadEngine* e,
-                           const SharedHandle<SocketCore>& socket);
+                           const std::shared_ptr<SocketCore>& socket);
 
   virtual ~WebSocketResponseCommand();
 };
diff --git a/src/WebSocketSession.cc b/src/WebSocketSession.cc
index 638876cf..6baa70bd 100644
--- a/src/WebSocketSession.cc
+++ b/src/WebSocketSession.cc
@@ -36,6 +36,7 @@
 
 #include <cerrno>
 #include <cstring>
+#include <cassert>
 
 #include "SocketCore.h"
 #include "LogFactory.h"
@@ -58,7 +59,7 @@ ssize_t sendCallback(wslay_event_context_ptr wsctx,
                       void* userData)
 {
   WebSocketSession* session = reinterpret_cast<WebSocketSession*>(userData);
-  const SharedHandle<SocketCore>& socket = session->getSocket();
+  const std::shared_ptr<SocketCore>& socket = session->getSocket();
   try {
     ssize_t r = socket->writeData(data, len);
     if(r == 0) {
@@ -84,7 +85,7 @@ ssize_t recvCallback(wslay_event_context_ptr wsctx,
                      void* userData)
 {
   WebSocketSession* session = reinterpret_cast<WebSocketSession*>(userData);
-  const SharedHandle<SocketCore>& socket = session->getSocket();
+  const std::shared_ptr<SocketCore>& socket = session->getSocket();
   try {
     ssize_t r;
     socket->readData(buf, len);
@@ -159,7 +160,7 @@ void onMsgRecvCallback(wslay_event_context_ptr wsctx,
   if(!wslay_is_ctrl_frame(arg->opcode)) {
     // TODO Only process text frame
     ssize_t error = 0;
-    SharedHandle<ValueBase> json = wsSession->parseFinal(0, 0, error);
+    std::shared_ptr<ValueBase> json = wsSession->parseFinal(0, 0, error);
     if(error < 0) {
       A2_LOG_INFO("Failed to parse JSON-RPC request");
       RpcResponse res
@@ -201,7 +202,7 @@ void onMsgRecvCallback(wslay_event_context_ptr wsctx,
 }
 } // namespace
 
-WebSocketSession::WebSocketSession(const SharedHandle<SocketCore>& socket,
+WebSocketSession::WebSocketSession(const std::shared_ptr<SocketCore>& socket,
                                    DownloadEngine* e)
   : socket_(socket),
     e_(e),
@@ -291,10 +292,10 @@ ssize_t WebSocketSession::parseUpdate(const uint8_t* data, size_t len)
   return parser_.parseUpdate(reinterpret_cast<const char*>(data), len);
 }
 
-SharedHandle<ValueBase> WebSocketSession::parseFinal
+std::shared_ptr<ValueBase> WebSocketSession::parseFinal
 (const uint8_t* data, size_t len, ssize_t& error)
 {
-  SharedHandle<ValueBase> res =
+  std::shared_ptr<ValueBase> res =
     parser_.parseFinal(reinterpret_cast<const char*>(data), len, error);
   receivedLength_ = 0;
   return res;
diff --git a/src/WebSocketSession.h b/src/WebSocketSession.h
index 71bba67a..4cd21fb9 100644
--- a/src/WebSocketSession.h
+++ b/src/WebSocketSession.h
@@ -37,9 +37,10 @@
 
 #include "common.h"
 
+#include <memory>
+
 #include <wslay/wslay.h>
 
-#include "SharedHandle.h"
 #include "ValueBaseJsonParser.h"
 
 namespace aria2 {
@@ -53,7 +54,7 @@ class WebSocketInteractionCommand;
 
 class WebSocketSession {
 public:
-  WebSocketSession(const SharedHandle<SocketCore>& socket,
+  WebSocketSession(const std::shared_ptr<SocketCore>& socket,
                    DownloadEngine* e);
   ~WebSocketSession();
   // Returns true if this session object wants to read data from the
@@ -85,10 +86,10 @@ public:
   // |error| will be the number of bytes processed if this function
   // succeeds, or negative error code. Whether success or failure,
   // this function resets parser state and receivedLength_.
-  SharedHandle<ValueBase> parseFinal(const uint8_t* data, size_t len,
+  std::shared_ptr<ValueBase> parseFinal(const uint8_t* data, size_t len,
                                      ssize_t& error);
 
-  const SharedHandle<SocketCore>& getSocket() const
+  const std::shared_ptr<SocketCore>& getSocket() const
   {
     return socket_;
   }
@@ -118,7 +119,7 @@ public:
     ignorePayload_ = flag;
   }
 private:
-  SharedHandle<SocketCore> socket_;
+  std::shared_ptr<SocketCore> socket_;
   DownloadEngine* e_;
   wslay_event_context_ptr wsctx_;
   bool ignorePayload_;
diff --git a/src/WebSocketSessionMan.cc b/src/WebSocketSessionMan.cc
index 54c96fac..edc961f0 100644
--- a/src/WebSocketSessionMan.cc
+++ b/src/WebSocketSessionMan.cc
@@ -33,6 +33,9 @@
  */
 /* copyright --> */
 #include "WebSocketSessionMan.h"
+
+#include <cassert>
+
 #include "WebSocketSession.h"
 #include "RequestGroup.h"
 #include "json.h"
@@ -49,14 +52,14 @@ WebSocketSessionMan::WebSocketSessionMan() {}
 WebSocketSessionMan::~WebSocketSessionMan() {}
 
 void WebSocketSessionMan::addSession
-(const SharedHandle<WebSocketSession>& wsSession)
+(const std::shared_ptr<WebSocketSession>& wsSession)
 {
   A2_LOG_DEBUG("WebSocket session added.");
   sessions_.insert(wsSession);
 }
 
 void WebSocketSessionMan::removeSession
-(const SharedHandle<WebSocketSession>& wsSession)
+(const std::shared_ptr<WebSocketSession>& wsSession)
 {
   A2_LOG_DEBUG("WebSocket session removed.");
   sessions_.erase(wsSession);
@@ -65,12 +68,12 @@ void WebSocketSessionMan::removeSession
 void WebSocketSessionMan::addNotification
 (const std::string& method, const RequestGroup* group)
 {
-  SharedHandle<Dict> dict = Dict::g();
+  std::shared_ptr<Dict> dict = Dict::g();
   dict->put("jsonrpc", "2.0");
   dict->put("method", method);
-  SharedHandle<Dict> eventSpec = Dict::g();
+  std::shared_ptr<Dict> eventSpec = Dict::g();
   eventSpec->put("gid", GroupId::toHex((group->getGID())));
-  SharedHandle<List> params = List::g();
+  std::shared_ptr<List> params = List::g();
   params->append(eventSpec);
   dict->put("params", params);
   std::string msg = json::encode(dict);
diff --git a/src/WebSocketSessionMan.h b/src/WebSocketSessionMan.h
index 4b2b5acc..d32654c0 100644
--- a/src/WebSocketSessionMan.h
+++ b/src/WebSocketSessionMan.h
@@ -39,8 +39,8 @@
 
 #include <set>
 #include <string>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "a2functional.h"
 
 namespace aria2 {
@@ -53,12 +53,12 @@ class WebSocketSession;
 
 class WebSocketSessionMan : public DownloadEventListener {
 public:
-  typedef std::set<SharedHandle<WebSocketSession>,
+  typedef std::set<std::shared_ptr<WebSocketSession>,
                    RefLess<WebSocketSession> > WebSocketSessions;
   WebSocketSessionMan();
   ~WebSocketSessionMan();
-  void addSession(const SharedHandle<WebSocketSession>& wsSession);
-  void removeSession(const SharedHandle<WebSocketSession>& wsSession);
+  void addSession(const std::shared_ptr<WebSocketSession>& wsSession);
+  void removeSession(const std::shared_ptr<WebSocketSession>& wsSession);
   void addNotification(const std::string& method, const RequestGroup* group);
   virtual void onEvent(DownloadEvent event, const RequestGroup* group);
 private:
diff --git a/src/WrDiskCache.cc b/src/WrDiskCache.cc
index cd204ea6..3238a35f 100644
--- a/src/WrDiskCache.cc
+++ b/src/WrDiskCache.cc
@@ -33,6 +33,9 @@
  */
 /* copyright --> */
 #include "WrDiskCache.h"
+
+#include <cassert>
+
 #include "WrDiskCacheEntry.h"
 #include "LogFactory.h"
 #include "fmt.h"
@@ -63,8 +66,8 @@ bool WrDiskCache::add(WrDiskCacheEntry* ent)
     ensureLimit();
     return true;
   } else {
-    A2_LOG_WARN(fmt("Found duplicate cache entry a.{size=%lu,clock=%"PRId64
-                    "} b{size=%lu,clock=%"PRId64"}",
+    A2_LOG_WARN(fmt("Found duplicate cache entry a.{size=%lu,clock=%" PRId64
+                    "} b{size=%lu,clock=%" PRId64 "}",
                     static_cast<unsigned long>((*rv.first)->getSize()),
                     (*rv.first)->getLastUpdate(),
                     static_cast<unsigned long>(ent->getSize()),
@@ -76,7 +79,7 @@ bool WrDiskCache::add(WrDiskCacheEntry* ent)
 bool WrDiskCache::remove(WrDiskCacheEntry* ent)
 {
   if(set_.erase(ent)) {
-    A2_LOG_DEBUG(fmt("Removed cache entry size=%lu, clock=%"PRId64,
+    A2_LOG_DEBUG(fmt("Removed cache entry size=%lu, clock=%" PRId64,
                      static_cast<unsigned long>(ent->getSize()),
                      ent->getLastUpdate()));
     total_ -= ent->getSize();
@@ -91,7 +94,7 @@ bool WrDiskCache::update(WrDiskCacheEntry* ent, ssize_t delta)
   if(!set_.erase(ent)) {
     return false;
   }
-  A2_LOG_DEBUG(fmt("Update cache entry size=%lu, delta=%ld, clock=%"PRId64,
+  A2_LOG_DEBUG(fmt("Update cache entry size=%lu, delta=%ld, clock=%" PRId64,
                    static_cast<unsigned long>(ent->getSize()),
                    static_cast<long>(delta),
                    ent->getLastUpdate()));
@@ -113,7 +116,7 @@ void WrDiskCache::ensureLimit()
   while(total_ > limit_) {
     EntrySet::iterator i = set_.begin();
     WrDiskCacheEntry* ent = *i;
-    A2_LOG_DEBUG(fmt("Force flush cache entry size=%lu, clock=%"PRId64,
+    A2_LOG_DEBUG(fmt("Force flush cache entry size=%lu, clock=%" PRId64,
                      static_cast<unsigned long>(ent->getSizeKey()),
                      ent->getLastUpdate()));
     total_ -= ent->getSize();
diff --git a/src/WrDiskCacheEntry.cc b/src/WrDiskCacheEntry.cc
index 9bdd2de8..5039a6c3 100644
--- a/src/WrDiskCacheEntry.cc
+++ b/src/WrDiskCacheEntry.cc
@@ -45,7 +45,7 @@
 namespace aria2 {
 
 WrDiskCacheEntry::WrDiskCacheEntry
-(const SharedHandle<DiskAdaptor>& diskAdaptor)
+(const std::shared_ptr<DiskAdaptor>& diskAdaptor)
   : sizeKey_(0),
     lastUpdate_(0),
     size_(0),
@@ -93,7 +93,7 @@ void WrDiskCacheEntry::clear()
 
 bool WrDiskCacheEntry::cacheData(DataCell* dataCell)
 {
-  A2_LOG_DEBUG(fmt("WrDiskCacheEntry cache goff=%"PRId64", len=%lu",
+  A2_LOG_DEBUG(fmt("WrDiskCacheEntry cache goff=%" PRId64 ", len=%lu",
                    dataCell->goff, static_cast<unsigned long>(dataCell->len)));
   if(set_.insert(dataCell).second) {
     size_ += dataCell->len;
diff --git a/src/WrDiskCacheEntry.h b/src/WrDiskCacheEntry.h
index cb0036ed..ba87e3e0 100644
--- a/src/WrDiskCacheEntry.h
+++ b/src/WrDiskCacheEntry.h
@@ -38,8 +38,8 @@
 #include "common.h"
 
 #include <set>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "a2functional.h"
 #include "error_code.h"
 
@@ -68,7 +68,7 @@ public:
 
   typedef std::set<DataCell*, DerefLess<DataCell*> > DataCellSet;
 
-  WrDiskCacheEntry(const SharedHandle<DiskAdaptor>& diskAdaptor);
+  WrDiskCacheEntry(const std::shared_ptr<DiskAdaptor>& diskAdaptor);
   ~WrDiskCacheEntry();
 
   // Flushes the cached data to the disk and deletes them.
@@ -140,7 +140,7 @@ private:
   int error_;
   error_code::Value errorCode_;
 
-  SharedHandle<DiskAdaptor> diskAdaptor_;
+  std::shared_ptr<DiskAdaptor> diskAdaptor_;
 };
 
 } // namespace aria2
diff --git a/src/XmlRpcDiskWriter.cc b/src/XmlRpcDiskWriter.cc
index 45b090c7..9aabd3cc 100644
--- a/src/XmlRpcDiskWriter.cc
+++ b/src/XmlRpcDiskWriter.cc
@@ -67,9 +67,9 @@ int XmlRpcDiskWriter::finalize()
 
 RpcRequest XmlRpcDiskWriter::getResult() const
 {
-  SharedHandle<List> params;
+  std::shared_ptr<List> params;
   if(downcast<List>(psm_.getCurrentFrameValue())) {
-    params = static_pointer_cast<List>(psm_.getCurrentFrameValue());
+    params = std::static_pointer_cast<List>(psm_.getCurrentFrameValue());
   } else {
     params = List::g();
   }
diff --git a/src/XmlRpcRequestParserController.cc b/src/XmlRpcRequestParserController.cc
index cf01aace..3401a4cd 100644
--- a/src/XmlRpcRequestParserController.cc
+++ b/src/XmlRpcRequestParserController.cc
@@ -75,7 +75,7 @@ void XmlRpcRequestParserController::popArrayFrame()
 }
 
 void XmlRpcRequestParserController::setCurrentFrameValue
-(const SharedHandle<ValueBase>& value)
+(const std::shared_ptr<ValueBase>& value)
 {
   currentFrame_.value_ = value;
 }
@@ -86,7 +86,7 @@ void XmlRpcRequestParserController::setCurrentFrameName
   currentFrame_.name_ = name;
 }
 
-const SharedHandle<ValueBase>&
+const std::shared_ptr<ValueBase>&
 XmlRpcRequestParserController::getCurrentFrameValue() const
 {
   return currentFrame_.value_;
diff --git a/src/XmlRpcRequestParserController.h b/src/XmlRpcRequestParserController.h
index f6499e87..36fa86f0 100644
--- a/src/XmlRpcRequestParserController.h
+++ b/src/XmlRpcRequestParserController.h
@@ -50,7 +50,7 @@ class XmlRpcRequestParserController {
 private:
 
   struct StateFrame {
-    SharedHandle<ValueBase> value_;
+    std::shared_ptr<ValueBase> value_;
     std::string name_;
 
     bool validMember() const
@@ -81,11 +81,11 @@ public:
   // to p and currentFrame_ = p;
   void popArrayFrame();
 
-  void setCurrentFrameValue(const SharedHandle<ValueBase>& value);
+  void setCurrentFrameValue(const std::shared_ptr<ValueBase>& value);
 
   void setCurrentFrameName(const std::string& name);
 
-  const SharedHandle<ValueBase>& getCurrentFrameValue() const;
+  const std::shared_ptr<ValueBase>& getCurrentFrameValue() const;
 
   void setMethodName(const std::string& methodName)
   {
diff --git a/src/XmlRpcRequestParserStateMachine.cc b/src/XmlRpcRequestParserStateMachine.cc
index 78fbf028..22b90246 100644
--- a/src/XmlRpcRequestParserStateMachine.cc
+++ b/src/XmlRpcRequestParserStateMachine.cc
@@ -166,12 +166,12 @@ void XmlRpcRequestParserStateMachine::pushFrame()
 }
 
 void XmlRpcRequestParserStateMachine::setCurrentFrameValue
-(const SharedHandle<ValueBase>& value)
+(const std::shared_ptr<ValueBase>& value)
 {
   controller_->setCurrentFrameValue(value);
 }
 
-const SharedHandle<ValueBase>&
+const std::shared_ptr<ValueBase>&
 XmlRpcRequestParserStateMachine::getCurrentFrameValue() const
 {
   return controller_->getCurrentFrameValue();
diff --git a/src/XmlRpcRequestParserStateMachine.h b/src/XmlRpcRequestParserStateMachine.h
index 93be50d5..7116df9f 100644
--- a/src/XmlRpcRequestParserStateMachine.h
+++ b/src/XmlRpcRequestParserStateMachine.h
@@ -39,8 +39,7 @@
 
 #include <string>
 #include <stack>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -78,8 +77,8 @@ public:
   void popArrayFrame();
   void popStructFrame();
   void pushFrame();
-  void setCurrentFrameValue(const SharedHandle<ValueBase>& value);
-  const SharedHandle<ValueBase>& getCurrentFrameValue() const;
+  void setCurrentFrameValue(const std::shared_ptr<ValueBase>& value);
+  const std::shared_ptr<ValueBase>& getCurrentFrameValue() const;
   void setCurrentFrameName(const std::string& name);
 
   void pushUnknownElementState();
diff --git a/src/a2functional.h b/src/a2functional.h
index c73bd567..a1cd9749 100644
--- a/src/a2functional.h
+++ b/src/a2functional.h
@@ -40,15 +40,15 @@
 #include <functional>
 #include <string>
 #include <algorithm>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "A2STR.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>
+class mem_fun_sh_t:public std::unary_function< std::shared_ptr<ClassType>, ReturnType>
 {
 private:
   ReturnType (ClassType::*f)();
@@ -56,7 +56,7 @@ private:
 public:
   mem_fun_sh_t(ReturnType (ClassType::*f)()):f(f) {}
 
-  ReturnType operator()(const SharedHandle<ClassType>& x) const
+  ReturnType operator()(const std::shared_ptr<ClassType>& x) const
   {
     return (x.get()->*f)();
   }
@@ -64,7 +64,7 @@ public:
 
 // const_mem_fun_t for SharedHandle
 template <class ReturnType, typename ClassType>
-class const_mem_fun_sh_t:public std::unary_function< SharedHandle<ClassType>, ReturnType>
+class const_mem_fun_sh_t:public std::unary_function< std::shared_ptr<ClassType>, ReturnType>
 {
 private:
   ReturnType (ClassType::*f)() const;
@@ -72,7 +72,7 @@ private:
 public:
   const_mem_fun_sh_t(ReturnType (ClassType::*f)() const):f(f) {}
 
-  ReturnType operator()(const SharedHandle<ClassType>& x) const
+  ReturnType operator()(const std::shared_ptr<ClassType>& x) const
   {
     return (x.get()->*f)();
   }
@@ -94,7 +94,7 @@ mem_fun_sh(ReturnType (ClassType::*f)() const)
 
 // mem_fun1_t for SharedHandle
 template<typename ReturnType, typename ClassType, typename ArgType>
-class mem_fun1_sh_t:public std::binary_function<SharedHandle<ClassType>,
+class mem_fun1_sh_t:public std::binary_function<std::shared_ptr<ClassType>,
                                                 ArgType,
                                                 ReturnType>
 {
@@ -104,7 +104,7 @@ private:
 public:
   mem_fun1_sh_t(ReturnType (ClassType::*f)(ArgType)):f(f) {}
 
-  ReturnType operator()(const SharedHandle<ClassType>& x, ArgType a) const
+  ReturnType operator()(const std::shared_ptr<ClassType>& x, ArgType a) const
   {
     return (x.get()->*f)(a);
   }
@@ -271,8 +271,8 @@ std::string strjoin(InputIterator first, InputIterator last,
 template<typename T>
 class LeastRecentAccess:public std::binary_function<T, T, bool> {
 public:
-  bool operator()(const SharedHandle<T>& lhs,
-                  const SharedHandle<T>& rhs) const
+  bool operator()(const std::shared_ptr<T>& lhs,
+                  const std::shared_ptr<T>& rhs) const
   {
     return lhs->getLastAccessTime() < rhs->getLastAccessTime();
   }
@@ -324,7 +324,7 @@ struct DerefEqual<T> derefEqual(const T& t)
 
 template<typename T>
 struct RefLess {
-  bool operator()(const SharedHandle<T>& lhs, const SharedHandle<T>& rhs) const
+  bool operator()(const std::shared_ptr<T>& lhs, const std::shared_ptr<T>& rhs) const
   {
     return lhs.get() < rhs.get();
   }
diff --git a/src/aria2api.cc b/src/aria2api.cc
index ff7beb65..bb5f6967 100644
--- a/src/aria2api.cc
+++ b/src/aria2api.cc
@@ -123,7 +123,7 @@ Session* sessionNew(const KeyVals& options, const SessionConfig& config)
       delete session;
       return 0;
     }
-    const SharedHandle<DownloadEngine>& e =
+    const std::shared_ptr<DownloadEngine>& e =
       session->context->reqinfo->getDownloadEngine();
     if(config.keepRunning) {
       e->getRequestGroupMan()->setKeepRunning(true);
@@ -131,7 +131,7 @@ Session* sessionNew(const KeyVals& options, const SessionConfig& config)
       e->addCommand(new KeepRunningCommand(e->newCUID(), e.get()));
     }
     if(config.downloadEventCallback) {
-      SharedHandle<DownloadEventListener> listener
+      std::shared_ptr<DownloadEventListener> listener
         (new ApiCallbackDownloadEventListener(session,
                                               config.downloadEventCallback,
                                               config.userData));
@@ -154,14 +154,14 @@ int sessionFinal(Session* session)
 
 int run(Session* session, RUN_MODE mode)
 {
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
   return e->run(mode == RUN_ONCE);
 }
 
 int shutdown(Session* session, bool force)
 {
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
   if(force) {
     e->requestForceHalt();
@@ -200,7 +200,7 @@ void apiGatherOption
 (InputIterator first, InputIterator last,
  Pred pred,
  Option* option,
- const SharedHandle<OptionParser>& optionParser)
+ const std::shared_ptr<OptionParser>& optionParser)
 {
   for(; first != last; ++first) {
     const std::string& optionName = (*first).first;
@@ -217,7 +217,7 @@ void apiGatherOption
 
 namespace {
 void apiGatherRequestOption(Option* option, const KeyVals& options,
-                            const SharedHandle<OptionParser>& optionParser)
+                            const std::shared_ptr<OptionParser>& optionParser)
 {
   apiGatherOption(options.begin(), options.end(),
                   std::mem_fun(&OptionHandler::getInitialOption),
@@ -227,7 +227,7 @@ void apiGatherRequestOption(Option* option, const KeyVals& options,
 
 namespace {
 void apiGatherChangeableOption(Option* option, const KeyVals& options,
-                               const SharedHandle<OptionParser>& optionParser)
+                               const std::shared_ptr<OptionParser>& optionParser)
 {
   apiGatherOption(options.begin(), options.end(),
                   std::mem_fun(&OptionHandler::getChangeOption),
@@ -238,7 +238,7 @@ void apiGatherChangeableOption(Option* option, const KeyVals& options,
 namespace {
 void apiGatherChangeableOptionForReserved
 (Option* option, const KeyVals& options,
- const SharedHandle<OptionParser>& optionParser)
+ const std::shared_ptr<OptionParser>& optionParser)
 {
   apiGatherOption(options.begin(), options.end(),
                   std::mem_fun(&OptionHandler::getChangeOptionForReserved),
@@ -249,7 +249,7 @@ void apiGatherChangeableOptionForReserved
 namespace {
 void apiGatherChangeableGlobalOption
 (Option* option, const KeyVals& options,
- const SharedHandle<OptionParser>& optionParser)
+ const std::shared_ptr<OptionParser>& optionParser)
 {
   apiGatherOption(options.begin(), options.end(),
                   std::mem_fun(&OptionHandler::getChangeGlobalOption),
@@ -258,8 +258,8 @@ void apiGatherChangeableGlobalOption
 } // namespace
 
 namespace {
-void addRequestGroup(const SharedHandle<RequestGroup>& group,
-                     const SharedHandle<DownloadEngine>& e,
+void addRequestGroup(const std::shared_ptr<RequestGroup>& group,
+                     const std::shared_ptr<DownloadEngine>& e,
                      int position)
 {
   if(position >= 0) {
@@ -276,9 +276,9 @@ int addUri(Session* session,
            const KeyVals& options,
            int position)
 {
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
-  SharedHandle<Option> requestOption(new Option(*e->getOption()));
+  std::shared_ptr<Option> requestOption(new Option(*e->getOption()));
   try {
     apiGatherRequestOption(requestOption.get(), options,
                            OptionParser::getInstance());
@@ -286,7 +286,7 @@ int addUri(Session* session,
     A2_LOG_INFO_EX(EX_EXCEPTION_CAUGHT, e);
     return -1;
   }
-  std::vector<SharedHandle<RequestGroup> > result;
+  std::vector<std::shared_ptr<RequestGroup> > result;
   createRequestGroupForUri(result, requestOption, uris,
                            /* ignoreForceSeq = */ true,
                            /* ignoreLocalPath = */ true);
@@ -306,10 +306,10 @@ int addMetalink(Session* session,
                 int position)
 {
 #ifdef ENABLE_METALINK
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
-  SharedHandle<Option> requestOption(new Option(*e->getOption()));
-  std::vector<SharedHandle<RequestGroup> > result;
+  std::shared_ptr<Option> requestOption(new Option(*e->getOption()));
+  std::vector<std::shared_ptr<RequestGroup> > result;
   try {
     apiGatherRequestOption(requestOption.get(), options,
                            OptionParser::getInstance());
@@ -326,7 +326,7 @@ int addMetalink(Session* session,
       e->getRequestGroupMan()->addReservedGroup(result);
     }
     if(gids) {
-      for(std::vector<SharedHandle<RequestGroup> >::const_iterator i =
+      for(std::vector<std::shared_ptr<RequestGroup> >::const_iterator i =
             result.begin(), eoi = result.end(); i != eoi; ++i) {
         (*gids).push_back((*i)->getGID());
       }
@@ -346,10 +346,10 @@ int addTorrent(Session* session,
                int position)
 {
 #ifdef ENABLE_BITTORRENT
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
-  SharedHandle<Option> requestOption(new Option(*e->getOption()));
-  std::vector<SharedHandle<RequestGroup> > result;
+  std::shared_ptr<Option> requestOption(new Option(*e->getOption()));
+  std::vector<std::shared_ptr<RequestGroup> > result;
   try {
     apiGatherRequestOption(requestOption.get(), options,
                            OptionParser::getInstance());
@@ -384,9 +384,9 @@ int addTorrent(Session* session,
 
 int removeDownload(Session* session, A2Gid gid, bool force)
 {
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
   if(group) {
     if(group->getState() == RequestGroup::STATE_ACTIVE) {
       if(force) {
@@ -410,9 +410,9 @@ int removeDownload(Session* session, A2Gid gid, bool force)
 
 int pauseDownload(Session* session, A2Gid gid, bool force)
 {
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
   if(group) {
     bool reserved = group->getState() == RequestGroup::STATE_WAITING;
     if(pauseRequestGroup(group, reserved, force)) {
@@ -425,9 +425,9 @@ int pauseDownload(Session* session, A2Gid gid, bool force)
 
 int unpauseDownload(Session* session, A2Gid gid)
 {
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
   if(!group ||
      group->getState() != RequestGroup::STATE_WAITING ||
      !group->isPauseRequested()) {
@@ -441,7 +441,7 @@ int unpauseDownload(Session* session, A2Gid gid)
 
 int changePosition(Session* session, A2Gid gid, int pos, OffsetMode how)
 {
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
   try {
     return e->getRequestGroupMan()->changeReservedGroupPosition(gid, pos, how);
@@ -453,9 +453,9 @@ int changePosition(Session* session, A2Gid gid, int pos, OffsetMode how)
 
 int changeOption(Session* session, A2Gid gid, const KeyVals& options)
 {
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
-  SharedHandle<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
+  std::shared_ptr<RequestGroup> group = e->getRequestGroupMan()->findGroup(gid);
   if(group) {
     Option option;
     try {
@@ -479,7 +479,7 @@ int changeOption(Session* session, A2Gid gid, const KeyVals& options)
 
 const std::string& getGlobalOption(Session* session, const std::string& name)
 {
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
   const Pref* pref = option::k2p(name);
   if(OptionParser::getInstance()->find(pref)) {
@@ -491,9 +491,9 @@ const std::string& getGlobalOption(Session* session, const std::string& name)
 
 KeyVals getGlobalOptions(Session* session)
 {
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
-  const SharedHandle<OptionParser>& optionParser = OptionParser::getInstance();
+  const std::shared_ptr<OptionParser>& optionParser = OptionParser::getInstance();
   const Option* option = e->getOption();
   KeyVals options;
   for(size_t i = 1, len = option::countOption(); i < len; ++i) {
@@ -507,7 +507,7 @@ KeyVals getGlobalOptions(Session* session)
 
 int changeGlobalOption(Session* session, const KeyVals& options)
 {
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
   Option option;
   try {
@@ -523,9 +523,9 @@ int changeGlobalOption(Session* session, const KeyVals& options)
 
 GlobalStat getGlobalStat(Session* session)
 {
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
-  const SharedHandle<RequestGroupMan>& rgman = e->getRequestGroupMan();
+  const std::shared_ptr<RequestGroupMan>& rgman = e->getRequestGroupMan();
   TransferStat ts = rgman->calculateStat();
   GlobalStat res;
   res.downloadSpeed = ts.downloadSpeed;
@@ -538,7 +538,7 @@ GlobalStat getGlobalStat(Session* session)
 
 std::vector<A2Gid> getActiveDownload(Session* session)
 {
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
   const RequestGroupList& groups = e->getRequestGroupMan()->getRequestGroups();
   std::vector<A2Gid> res;
@@ -568,7 +568,7 @@ void createUriEntry
 namespace {
 template<typename OutputIterator>
 void createUriEntry
-(OutputIterator out, const SharedHandle<FileEntry>& file)
+(OutputIterator out, const std::shared_ptr<FileEntry>& file)
 {
   createUriEntry(out,
                  file->getSpentUris().begin(),
@@ -583,7 +583,7 @@ void createUriEntry
 
 namespace {
 FileData createFileData
-(const SharedHandle<FileEntry>& fe, int index, const BitfieldMan* bf)
+(const std::shared_ptr<FileEntry>& fe, int index, const BitfieldMan* bf)
 {
   FileData file;
   file.index = index;
@@ -634,7 +634,7 @@ void createFileEntry
  InputIterator first, InputIterator last,
  int64_t totalLength,
  int32_t pieceLength,
- const SharedHandle<PieceStorage>& ps)
+ const std::shared_ptr<PieceStorage>& ps)
 {
   BitfieldMan bf(pieceLength, totalLength);
   if(ps) {
@@ -648,8 +648,8 @@ namespace {
 template<typename OutputIterator>
 void pushRequestOption
 (OutputIterator out,
- const SharedHandle<Option>& option,
- const SharedHandle<OptionParser>& oparser)
+ const std::shared_ptr<Option>& option,
+ const std::shared_ptr<OptionParser>& oparser)
 {
   for(size_t i = 1, len = option::countOption(); i < len; ++i) {
     const Pref* pref = option::i2p(i);
@@ -662,7 +662,7 @@ void pushRequestOption
 } // namespace
 
 namespace {
-const std::string& getRequestOption(const SharedHandle<Option>& option,
+const std::string& getRequestOption(const std::shared_ptr<Option>& option,
                                     const std::string& name)
 {
   const Pref* pref = option::k2p(name);
@@ -675,7 +675,7 @@ const std::string& getRequestOption(const SharedHandle<Option>& option,
 } // namespace
 
 namespace {
-KeyVals getRequestOptions(const SharedHandle<Option>& option)
+KeyVals getRequestOptions(const std::shared_ptr<Option>& option)
 {
   KeyVals res;
   pushRequestOption(std::back_inserter(res), option,
@@ -686,7 +686,7 @@ KeyVals getRequestOptions(const SharedHandle<Option>& option)
 
 namespace {
 struct RequestGroupDH : public DownloadHandle {
-  RequestGroupDH(const SharedHandle<RequestGroup>& group)
+  RequestGroupDH(const std::shared_ptr<RequestGroup>& group)
     : group(group),
       ts(group->calculateStat())
   {}
@@ -717,7 +717,7 @@ struct RequestGroupDH : public DownloadHandle {
   }
   virtual std::string getBitfield()
   {
-    const SharedHandle<PieceStorage>& ps = group->getPieceStorage();
+    const std::shared_ptr<PieceStorage>& ps = group->getPieceStorage();
     if(ps) {
       return std::string(reinterpret_cast<const char*>(ps->getBitfield()),
                          ps->getBitfieldLength());
@@ -737,7 +737,7 @@ struct RequestGroupDH : public DownloadHandle {
   {
 #ifdef ENABLE_BITTORRENT
     if(group->getDownloadContext()->hasAttribute(CTX_ATTR_BT)) {
-      SharedHandle<TorrentAttribute> torrentAttrs =
+      std::shared_ptr<TorrentAttribute> torrentAttrs =
         bittorrent::getTorrentAttrs(group->getDownloadContext());
       return torrentAttrs->infoHash;
     }
@@ -746,7 +746,7 @@ struct RequestGroupDH : public DownloadHandle {
   }
   virtual size_t getPieceLength()
   {
-    const SharedHandle<DownloadContext>& dctx = group->getDownloadContext();
+    const std::shared_ptr<DownloadContext>& dctx = group->getDownloadContext();
     return dctx->getPieceLength();
   }
   virtual int getNumPieces()
@@ -776,7 +776,7 @@ struct RequestGroupDH : public DownloadHandle {
   virtual std::vector<FileData> getFiles()
   {
     std::vector<FileData> res;
-    const SharedHandle<DownloadContext>& dctx = group->getDownloadContext();
+    const std::shared_ptr<DownloadContext>& dctx = group->getDownloadContext();
     createFileEntry(std::back_inserter(res),
                     dctx->getFileEntries().begin(),
                     dctx->getFileEntries().end(),
@@ -786,14 +786,14 @@ struct RequestGroupDH : public DownloadHandle {
   }
   virtual int getNumFiles()
   {
-    const SharedHandle<DownloadContext>& dctx = group->getDownloadContext();
+    const std::shared_ptr<DownloadContext>& dctx = group->getDownloadContext();
     return dctx->getFileEntries().size();
   }
   virtual FileData getFile(int index)
   {
-    const SharedHandle<DownloadContext>& dctx = group->getDownloadContext();
+    const std::shared_ptr<DownloadContext>& dctx = group->getDownloadContext();
     BitfieldMan bf(dctx->getPieceLength(), dctx->getTotalLength());
-    const SharedHandle<PieceStorage>& ps = group->getPieceStorage();
+    const std::shared_ptr<PieceStorage>& ps = group->getPieceStorage();
     if(ps) {
       bf.setBitfield(ps->getBitfield(), ps->getBitfieldLength());
     }
@@ -804,7 +804,7 @@ struct RequestGroupDH : public DownloadHandle {
     BtMetaInfoData res;
 #ifdef ENABLE_BITTORRENT
     if(group->getDownloadContext()->hasAttribute(CTX_ATTR_BT)) {
-      SharedHandle<TorrentAttribute> torrentAttrs =
+      std::shared_ptr<TorrentAttribute> torrentAttrs =
         bittorrent::getTorrentAttrs(group->getDownloadContext());
       res.announceList = torrentAttrs->announceList;
       res.comment = torrentAttrs->comment;
@@ -829,14 +829,14 @@ struct RequestGroupDH : public DownloadHandle {
   {
     return getRequestOptions(group->getOption());
   }
-  SharedHandle<RequestGroup> group;
+  std::shared_ptr<RequestGroup> group;
   TransferStat ts;
 };
 } // namespace
 
 namespace {
 struct DownloadResultDH : public DownloadHandle {
-  DownloadResultDH(const SharedHandle<DownloadResult>& dr)
+  DownloadResultDH(const std::shared_ptr<DownloadResult>& dr)
     : dr(dr)
   {}
   virtual ~DownloadResultDH() {}
@@ -938,20 +938,20 @@ struct DownloadResultDH : public DownloadHandle {
   {
     return getRequestOptions(dr->option);
   }
-  SharedHandle<DownloadResult> dr;
+  std::shared_ptr<DownloadResult> dr;
 };
 } // namespace
 
 DownloadHandle* getDownloadHandle(Session* session, A2Gid gid)
 {
-  const SharedHandle<DownloadEngine>& e =
+  const std::shared_ptr<DownloadEngine>& e =
     session->context->reqinfo->getDownloadEngine();
-  const SharedHandle<RequestGroupMan>& rgman = e->getRequestGroupMan();
-  SharedHandle<RequestGroup> group = rgman->findGroup(gid);
+  const std::shared_ptr<RequestGroupMan>& rgman = e->getRequestGroupMan();
+  std::shared_ptr<RequestGroup> group = rgman->findGroup(gid);
   if(group) {
     return new RequestGroupDH(group);
   } else {
-    SharedHandle<DownloadResult> ds = rgman->findDownloadResult(gid);
+    std::shared_ptr<DownloadResult> ds = rgman->findDownloadResult(gid);
     if(ds) {
       return new DownloadResultDH(ds);
     }
diff --git a/src/aria2api.h b/src/aria2api.h
index 29fe529e..59985dca 100644
--- a/src/aria2api.h
+++ b/src/aria2api.h
@@ -37,8 +37,9 @@
 
 #include "common.h"
 
+#include <memory>
+
 #include <aria2/aria2.h>
-#include "SharedHandle.h"
 
 namespace aria2 {
 
@@ -47,7 +48,7 @@ struct Context;
 struct Session {
   Session(const KeyVals& options);
   ~Session();
-  SharedHandle<Context> context;
+  std::shared_ptr<Context> context;
 };
 
 } // namespace aria2
diff --git a/src/bencode2.cc b/src/bencode2.cc
index 2e5b2e6a..00bb2a78 100644
--- a/src/bencode2.cc
+++ b/src/bencode2.cc
@@ -47,25 +47,25 @@ namespace aria2 {
 
 namespace bencode2 {
 
-SharedHandle<ValueBase> decode(const unsigned char* data, size_t len)
+std::shared_ptr<ValueBase> decode(const unsigned char* data, size_t len)
 {
   size_t end;
   return decode(data, len, end);
 }
 
-SharedHandle<ValueBase> decode(const std::string& data)
+std::shared_ptr<ValueBase> decode(const std::string& data)
 {
   size_t end;
   return decode(reinterpret_cast<const unsigned char*>(data.c_str()),
                 data.size(), end);
 }
 
-SharedHandle<ValueBase> decode(const unsigned char* data, size_t len,
+std::shared_ptr<ValueBase> decode(const unsigned char* data, size_t len,
                                size_t& end)
 {
   ssize_t error;
   bittorrent::ValueBaseBencodeParser parser;
-  SharedHandle<ValueBase> res =
+  std::shared_ptr<ValueBase> res =
     parser.parseFinal(reinterpret_cast<const char*>(data), len, error);
   if(error < 0) {
     throw DL_ABORT_EX2(fmt("Bencode decoding failed: error=%d",
@@ -130,7 +130,7 @@ std::string encode(const ValueBase* vlb)
   return visitor.getResult();
 }
 
-std::string encode(const SharedHandle<ValueBase>& vlb)
+std::string encode(const std::shared_ptr<ValueBase>& vlb)
 {
   return encode(vlb.get());
 }
diff --git a/src/bencode2.h b/src/bencode2.h
index 7da4c2fd..e3896a3e 100644
--- a/src/bencode2.h
+++ b/src/bencode2.h
@@ -46,20 +46,20 @@ namespace aria2 {
 namespace bencode2 {
 
 // Decode the data whose length is len.
-SharedHandle<ValueBase> decode(const unsigned char* data, size_t len);
+std::shared_ptr<ValueBase> decode(const unsigned char* data, size_t len);
 
-SharedHandle<ValueBase> decode(const std::string& data);
+std::shared_ptr<ValueBase> decode(const std::string& data);
 
 // Decode the data whose length is len. After decode is done
 // successfully, return the bencoded string length in end.
-SharedHandle<ValueBase> decode(const unsigned char* data, size_t len,
+std::shared_ptr<ValueBase> decode(const unsigned char* data, size_t len,
                                size_t& end);
 
-SharedHandle<ValueBase> decodeFromFile(const std::string& filename);
+std::shared_ptr<ValueBase> decodeFromFile(const std::string& filename);
 
 std::string encode(const ValueBase* vlb);
 
-std::string encode(const SharedHandle<ValueBase>& vlb);
+std::string encode(const std::shared_ptr<ValueBase>& vlb);
 
 } // namespace bencode2
 
diff --git a/src/bittorrent_helper.cc b/src/bittorrent_helper.cc
index 7b85f64d..4850ea56 100644
--- a/src/bittorrent_helper.cc
+++ b/src/bittorrent_helper.cc
@@ -112,7 +112,7 @@ const std::string MULTI("multi");
 const std::string SINGLE("single");
 
 namespace {
-void extractPieceHash(const SharedHandle<DownloadContext>& ctx,
+void extractPieceHash(const std::shared_ptr<DownloadContext>& ctx,
                       const std::string& hashData,
                       size_t hashLength,
                       size_t numPieces)
@@ -129,17 +129,17 @@ void extractPieceHash(const SharedHandle<DownloadContext>& ctx,
 
 namespace {
 void extractUrlList
-(const SharedHandle<TorrentAttribute>& torrent, std::vector<std::string>& uris,
+(const std::shared_ptr<TorrentAttribute>& torrent, std::vector<std::string>& uris,
  const ValueBase* v)
 {
   class UrlListVisitor:public ValueBaseVisitor {
   private:
     std::vector<std::string>& uris_;
-    const SharedHandle<TorrentAttribute>& torrent_;
+    const std::shared_ptr<TorrentAttribute>& torrent_;
   public:
     UrlListVisitor
     (std::vector<std::string>& uris,
-     const SharedHandle<TorrentAttribute>& torrent):
+     const std::shared_ptr<TorrentAttribute>& torrent):
       uris_(uris), torrent_(torrent) {}
 
     virtual void visit(const String& v)
@@ -194,10 +194,10 @@ OutputIterator createUri
 
 namespace {
 void extractFileEntries
-(const SharedHandle<DownloadContext>& ctx,
- const SharedHandle<TorrentAttribute>& torrent,
+(const std::shared_ptr<DownloadContext>& ctx,
+ const std::shared_ptr<TorrentAttribute>& torrent,
  const Dict* infoDict,
- const SharedHandle<Option>& option,
+ const std::shared_ptr<Option>& option,
  const std::string& defaultName,
  const std::string& overrideName,
  const std::vector<std::string>& urlList)
@@ -228,7 +228,7 @@ void extractFileEntries
   }
   torrent->name = utf8Name;
   int maxConn = option->getAsInt(PREF_MAX_CONNECTION_PER_SERVER);
-  std::vector<SharedHandle<FileEntry> > fileEntries;
+  std::vector<std::shared_ptr<FileEntry> > fileEntries;
   const List* filesList = downcast<List>(infoDict->get(C_FILES));
   if(filesList) {
     fileEntries.reserve(filesList->size());
@@ -292,7 +292,7 @@ void extractFileEntries
                              (util::percentEncode)));
       std::vector<std::string> uris;
       createUri(urlList.begin(), urlList.end(),std::back_inserter(uris),pePath);
-      SharedHandle<FileEntry> fileEntry
+      std::shared_ptr<FileEntry> fileEntry
         (new FileEntry(util::applyDir(option->get(PREF_DIR),
                                       util::escapePath(utf8Path)),
                        fileLengthData->i(), offset, uris));
@@ -324,7 +324,7 @@ void extractFileEntries
         uris.push_back(*i);
       }
     }
-    SharedHandle<FileEntry> fileEntry
+    std::shared_ptr<FileEntry> fileEntry
       (new FileEntry(util::applyDir(option->get(PREF_DIR),
                                     util::escapePath(utf8Name)),
                      totalLength, 0, uris));
@@ -342,7 +342,7 @@ void extractFileEntries
 
 namespace {
 void extractAnnounce
-(const SharedHandle<TorrentAttribute>& torrent, const Dict* rootDict)
+(const std::shared_ptr<TorrentAttribute>& torrent, const Dict* rootDict)
 {
   const List* announceList = downcast<List>(rootDict->get(C_ANNOUNCE_LIST));
   if(announceList) {
@@ -377,7 +377,7 @@ void extractAnnounce
 
 namespace {
 void extractNodes
-(const SharedHandle<TorrentAttribute>& torrent, const ValueBase* nodesListSrc)
+(const std::shared_ptr<TorrentAttribute>& torrent, const ValueBase* nodesListSrc)
 {
   const List* nodesList = downcast<List>(nodesListSrc);
   if(nodesList) {
@@ -408,9 +408,9 @@ void extractNodes
 
 namespace {
 void processRootDictionary
-(const SharedHandle<DownloadContext>& ctx,
- const SharedHandle<ValueBase>& root,
- const SharedHandle<Option>& option,
+(const std::shared_ptr<DownloadContext>& ctx,
+ const std::shared_ptr<ValueBase>& root,
+ const std::shared_ptr<Option>& option,
  const std::string& defaultName,
  const std::string& overrideName,
  const std::vector<std::string>& uris)
@@ -425,7 +425,7 @@ void processRootDictionary
     throw DL_ABORT_EX2(fmt(MSG_MISSING_BT_INFO, C_INFO.c_str()),
                        error_code::BITTORRENT_PARSE_ERROR);
   }
-  SharedHandle<TorrentAttribute> torrent(new TorrentAttribute());
+  std::shared_ptr<TorrentAttribute> torrent(new TorrentAttribute());
 
   // retrieve infoHash
   std::string encodedInfoDict = bencode2::encode(infoDict);
@@ -518,8 +518,8 @@ void processRootDictionary
 } // namespace
 
 void load(const std::string& torrentFile,
-          const SharedHandle<DownloadContext>& ctx,
-          const SharedHandle<Option>& option,
+          const std::shared_ptr<DownloadContext>& ctx,
+          const std::shared_ptr<Option>& option,
           const std::string& overrideName)
 {
   ValueBaseBencodeParser parser;
@@ -532,8 +532,8 @@ void load(const std::string& torrentFile,
 }
 
 void load(const std::string& torrentFile,
-          const SharedHandle<DownloadContext>& ctx,
-          const SharedHandle<Option>& option,
+          const std::shared_ptr<DownloadContext>& ctx,
+          const std::shared_ptr<Option>& option,
           const std::vector<std::string>& uris,
           const std::string& overrideName)
 {
@@ -548,8 +548,8 @@ void load(const std::string& torrentFile,
 
 void loadFromMemory(const unsigned char* content,
                     size_t length,
-                    const SharedHandle<DownloadContext>& ctx,
-                    const SharedHandle<Option>& option,
+                    const std::shared_ptr<DownloadContext>& ctx,
+                    const std::shared_ptr<Option>& option,
                     const std::string& defaultName,
                     const std::string& overrideName)
 {
@@ -563,8 +563,8 @@ void loadFromMemory(const unsigned char* content,
 
 void loadFromMemory(const unsigned char* content,
                     size_t length,
-                    const SharedHandle<DownloadContext>& ctx,
-                    const SharedHandle<Option>& option,
+                    const std::shared_ptr<DownloadContext>& ctx,
+                    const std::shared_ptr<Option>& option,
                     const std::vector<std::string>& uris,
                     const std::string& defaultName,
                     const std::string& overrideName)
@@ -578,8 +578,8 @@ void loadFromMemory(const unsigned char* content,
 }
 
 void loadFromMemory(const std::string& context,
-                    const SharedHandle<DownloadContext>& ctx,
-                    const SharedHandle<Option>& option,
+                    const std::shared_ptr<DownloadContext>& ctx,
+                    const std::shared_ptr<Option>& option,
                     const std::string& defaultName,
                     const std::string& overrideName)
 {
@@ -592,8 +592,8 @@ void loadFromMemory(const std::string& context,
 }
 
 void loadFromMemory(const std::string& context,
-                    const SharedHandle<DownloadContext>& ctx,
-                    const SharedHandle<Option>& option,
+                    const std::shared_ptr<DownloadContext>& ctx,
+                    const std::shared_ptr<Option>& option,
                     const std::vector<std::string>& uris,
                     const std::string& defaultName,
                     const std::string& overrideName)
@@ -606,9 +606,9 @@ void loadFromMemory(const std::string& context,
      uris);
 }
 
-void loadFromMemory(const SharedHandle<ValueBase>& torrent,
-                    const SharedHandle<DownloadContext>& ctx,
-                    const SharedHandle<Option>& option,
+void loadFromMemory(const std::shared_ptr<ValueBase>& torrent,
+                    const std::shared_ptr<DownloadContext>& ctx,
+                    const std::shared_ptr<Option>& option,
                     const std::vector<std::string>& uris,
                     const std::string& defaultName,
                     const std::string& overrideName)
@@ -621,21 +621,22 @@ void loadFromMemory(const SharedHandle<ValueBase>& torrent,
      uris);
 }
 
-SharedHandle<TorrentAttribute> getTorrentAttrs
-(const SharedHandle<DownloadContext>& dctx)
+std::shared_ptr<TorrentAttribute> getTorrentAttrs
+(const std::shared_ptr<DownloadContext>& dctx)
 {
-  return static_pointer_cast<TorrentAttribute>(dctx->getAttribute(CTX_ATTR_BT));
+  return std::static_pointer_cast<TorrentAttribute>
+    (dctx->getAttribute(CTX_ATTR_BT));
 }
 
 const unsigned char*
-getInfoHash(const SharedHandle<DownloadContext>& dctx)
+getInfoHash(const std::shared_ptr<DownloadContext>& dctx)
 {
   return reinterpret_cast<const unsigned char*>
     (getTorrentAttrs(dctx)->infoHash.data());
 }
 
 std::string
-getInfoHashString(const SharedHandle<DownloadContext>& dctx)
+getInfoHashString(const std::shared_ptr<DownloadContext>& dctx)
 {
   return util::toHex(getTorrentAttrs(dctx)->infoHash);
 }
@@ -662,7 +663,7 @@ void computeFastSet
   }
   memcpy(tx+4, infoHash, 20);
   unsigned char x[20];
-  SharedHandle<MessageDigest> sha1 = MessageDigest::sha1();
+  std::shared_ptr<MessageDigest> sha1 = MessageDigest::sha1();
   message_digest::digest(x, sizeof(x), sha1, tx, 24);
   while(fastSet.size() < fastSetSize) {
     for(size_t i = 0; i < 5 && fastSet.size() < fastSetSize; ++i) {
@@ -890,9 +891,9 @@ void assertID
   }
 }
 
-SharedHandle<TorrentAttribute> parseMagnet(const std::string& magnet)
+std::shared_ptr<TorrentAttribute> parseMagnet(const std::string& magnet)
 {
-  SharedHandle<Dict> r = magnet::parse(magnet);
+  std::shared_ptr<Dict> r = magnet::parse(magnet);
   if(!r) {
     throw DL_ABORT_EX2("Bad BitTorrent Magnet URI.",
                        error_code::MAGNET_PARSE_ERROR);
@@ -902,7 +903,7 @@ SharedHandle<TorrentAttribute> parseMagnet(const std::string& magnet)
     throw DL_ABORT_EX2("Missing xt parameter in Magnet URI.",
                        error_code::MAGNET_PARSE_ERROR);
   }
-  SharedHandle<TorrentAttribute> attrs(new TorrentAttribute());
+  std::shared_ptr<TorrentAttribute> attrs(new TorrentAttribute());
   std::string infoHash;
   for(List::ValueType::const_iterator xtiter = xts->begin(),
         eoi = xts->end(); xtiter != eoi && infoHash.empty(); ++xtiter) {
@@ -950,14 +951,14 @@ SharedHandle<TorrentAttribute> parseMagnet(const std::string& magnet)
 }
 
 void loadMagnet
-(const std::string& magnet, const SharedHandle<DownloadContext>& dctx)
+(const std::string& magnet, const std::shared_ptr<DownloadContext>& dctx)
 {
-  SharedHandle<TorrentAttribute> attrs = parseMagnet(magnet);
+  std::shared_ptr<TorrentAttribute> attrs = parseMagnet(magnet);
   dctx->setAttribute(CTX_ATTR_BT, attrs);
 }
 
 std::string metadata2Torrent
-(const std::string& metadata, const SharedHandle<TorrentAttribute>& attrs)
+(const std::string& metadata, const std::shared_ptr<TorrentAttribute>& attrs)
 {
   std::string torrent = "d";
 
@@ -965,7 +966,7 @@ std::string metadata2Torrent
   for(std::vector<std::vector<std::string> >::const_iterator tierIter =
         attrs->announceList.begin(),
         eoi = attrs->announceList.end(); tierIter != eoi; ++tierIter) {
-    SharedHandle<List> tier = List::g();
+    std::shared_ptr<List> tier = List::g();
     for(std::vector<std::string>::const_iterator uriIter = (*tierIter).begin(),
           eoi2 = (*tierIter).end(); uriIter != eoi2; ++uriIter) {
       tier->append(String::g(*uriIter));
@@ -984,7 +985,7 @@ std::string metadata2Torrent
   return torrent;
 }
 
-std::string torrent2Magnet(const SharedHandle<TorrentAttribute>& attrs)
+std::string torrent2Magnet(const std::shared_ptr<TorrentAttribute>& attrs)
 {
   std::string uri = "magnet:?";
   if(!attrs->infoHash.empty()) {
@@ -1021,7 +1022,7 @@ int getCompactLength(int family)
 }
 
 void removeAnnounceUri
-(const SharedHandle<TorrentAttribute>& attrs,
+(const std::shared_ptr<TorrentAttribute>& attrs,
  const std::vector<std::string>& uris)
 {
   if(uris.empty()) {
@@ -1049,7 +1050,7 @@ void removeAnnounceUri
 }
 
 void addAnnounceUri
-(const SharedHandle<TorrentAttribute>& attrs,
+(const std::shared_ptr<TorrentAttribute>& attrs,
  const std::vector<std::string>& uris)
 {
   for(std::vector<std::string>::const_iterator i = uris.begin(),
@@ -1061,8 +1062,8 @@ void addAnnounceUri
 }
 
 void adjustAnnounceUri
-(const SharedHandle<TorrentAttribute>& attrs,
- const SharedHandle<Option>& option)
+(const std::shared_ptr<TorrentAttribute>& attrs,
+ const std::shared_ptr<Option>& option)
 {
   std::vector<std::string> excludeUris;
   std::vector<std::string> addUris;
diff --git a/src/bittorrent_helper.h b/src/bittorrent_helper.h
index ba19c79f..d26d3af1 100644
--- a/src/bittorrent_helper.h
+++ b/src/bittorrent_helper.h
@@ -41,8 +41,8 @@
 #include <string>
 #include <vector>
 #include <utility>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "TorrentAttribute.h"
 #include "a2netcompat.h"
 #include "Peer.h"
@@ -65,51 +65,51 @@ extern const std::string SINGLE;
 extern const std::string MULTI;
 
 void load(const std::string& torrentFile,
-          const SharedHandle<DownloadContext>& ctx,
-          const SharedHandle<Option>& option,
+          const std::shared_ptr<DownloadContext>& ctx,
+          const std::shared_ptr<Option>& option,
           const std::string& overrideName = "");
 
 void load(const std::string& torrentFile,
-          const SharedHandle<DownloadContext>& ctx,
-          const SharedHandle<Option>& option,
+          const std::shared_ptr<DownloadContext>& ctx,
+          const std::shared_ptr<Option>& option,
           const std::vector<std::string>& uris,
           const std::string& overrideName = "");
 
 void loadFromMemory(const unsigned char* content, size_t length,
-                    const SharedHandle<DownloadContext>& ctx,
-                    const SharedHandle<Option>& option,
+                    const std::shared_ptr<DownloadContext>& ctx,
+                    const std::shared_ptr<Option>& option,
                     const std::string& defaultName,
                     const std::string& overrideName = "");
 
 void loadFromMemory(const unsigned char* content, size_t length,
-                    const SharedHandle<DownloadContext>& ctx,
-                    const SharedHandle<Option>& option,
+                    const std::shared_ptr<DownloadContext>& ctx,
+                    const std::shared_ptr<Option>& option,
                     const std::vector<std::string>& uris,
                     const std::string& defaultName,
                     const std::string& overrideName = "");
 
 void loadFromMemory(const std::string& context,
-                    const SharedHandle<DownloadContext>& ctx,
-                    const SharedHandle<Option>& option,
+                    const std::shared_ptr<DownloadContext>& ctx,
+                    const std::shared_ptr<Option>& option,
                     const std::string& defaultName,
                     const std::string& overrideName = "");
 
 void loadFromMemory(const std::string& context,
-                    const SharedHandle<DownloadContext>& ctx,
-                    const SharedHandle<Option>& option,
+                    const std::shared_ptr<DownloadContext>& ctx,
+                    const std::shared_ptr<Option>& option,
                     const std::vector<std::string>& uris,
                     const std::string& defaultName,
                     const std::string& overrideName = "");
 
-void loadFromMemory(const SharedHandle<ValueBase>& torrent,
-                    const SharedHandle<DownloadContext>& ctx,
-                    const SharedHandle<Option>& option,
+void loadFromMemory(const std::shared_ptr<ValueBase>& torrent,
+                    const std::shared_ptr<DownloadContext>& ctx,
+                    const std::shared_ptr<Option>& option,
                     const std::vector<std::string>& uris,
                     const std::string& defaultName,
                     const std::string& overrideName = "");
 
 // Parses BitTorrent Magnet URI and returns
-// SharedHandle<TorrentAttribute> which includes infoHash, name and
+// std::shared_ptr<TorrentAttribute> which includes infoHash, name and
 // announceList. If parsing operation failed, an RecoverableException
 // will be thrown.  infoHash and name are string and announceList is a
 // list of list of announce URI.
@@ -117,13 +117,13 @@ void loadFromMemory(const SharedHandle<ValueBase>& torrent,
 // magnet:?xt=urn:btih:<info-hash>&dn=<name>&tr=<tracker-url>
 // <info-hash> comes in 2 flavors: 40bytes hexadecimal ascii string,
 // or 32bytes Base32 encoded string.
-SharedHandle<TorrentAttribute> parseMagnet(const std::string& magnet);
+std::shared_ptr<TorrentAttribute> parseMagnet(const std::string& magnet);
 
 // Parses BitTorrent Magnet URI and set them in ctx as a
 // bittorrent::BITTORRENT attibute. If parsing operation failed, an
 // RecoverableException will be thrown.
 void loadMagnet
-(const std::string& magnet, const SharedHandle<DownloadContext>& ctx);
+(const std::string& magnet, const std::shared_ptr<DownloadContext>& ctx);
 
 // Generates Peer ID. BitTorrent specification says Peer ID is 20-byte
 // length.  This function uses peerIdPrefix as a Peer ID and it is
@@ -149,16 +149,16 @@ void computeFastSet
 (std::vector<size_t>& fastSet, const std::string& ipaddr,
  size_t numPieces, const unsigned char* infoHash, size_t fastSetSize);
 
-SharedHandle<TorrentAttribute> getTorrentAttrs
-(const SharedHandle<DownloadContext>& dctx);
+std::shared_ptr<TorrentAttribute> getTorrentAttrs
+(const std::shared_ptr<DownloadContext>& dctx);
 
 // Returns the value associated with INFO_HASH key in BITTORRENT
 // attribute.
 const unsigned char*
-getInfoHash(const SharedHandle<DownloadContext>& downloadContext);
+getInfoHash(const std::shared_ptr<DownloadContext>& downloadContext);
 
 std::string
-getInfoHashString(const SharedHandle<DownloadContext>& downloadContext);
+getInfoHashString(const std::shared_ptr<DownloadContext>& downloadContext);
 
 // Returns 8bytes unsigned integer located at offset pos.  The integer
 // in msg is network byte order. This function converts it into host
@@ -237,21 +237,21 @@ void assertID
 // Converts attrs into torrent data. This function does not guarantee
 // the returned string is valid torrent data.
 std::string metadata2Torrent
-(const std::string& metadata, const SharedHandle<TorrentAttribute>& attrs);
+(const std::string& metadata, const std::shared_ptr<TorrentAttribute>& attrs);
 
 // Constructs BitTorrent Magnet URI using attrs.
-std::string torrent2Magnet(const SharedHandle<TorrentAttribute>& attrs);
+std::string torrent2Magnet(const std::shared_ptr<TorrentAttribute>& attrs);
 
 // Removes announce URI in uris from attrs.  If uris contains '*', all
 // announce URIs are removed.
 void removeAnnounceUri
-(const SharedHandle<TorrentAttribute>& attrs,
+(const std::shared_ptr<TorrentAttribute>& attrs,
  const std::vector<std::string>& uris);
 
 // Adds announce URI in uris to attrs. Each URI in uris creates its
 // own tier.
 void addAnnounceUri
-(const SharedHandle<TorrentAttribute>& attrs,
+(const std::shared_ptr<TorrentAttribute>& attrs,
  const std::vector<std::string>& uris);
 
 // This helper function uses 2 option values: PREF_BT_TRACKER and
@@ -260,8 +260,8 @@ void addAnnounceUri
 // and call removeAnnounceUri(). Then the value of PREF_BT_TRACKER is
 // converted to std::vector<std::string> and call addAnnounceUri().
 void adjustAnnounceUri
-(const SharedHandle<TorrentAttribute>& attrs,
- const SharedHandle<Option>& option);
+(const std::shared_ptr<TorrentAttribute>& attrs,
+ const std::shared_ptr<Option>& option);
 
 template<typename OutputIterator>
 void extractPeer(const ValueBase* peerData, int family, OutputIterator dest)
@@ -290,7 +290,7 @@ void extractPeer(const ValueBase* peerData, int family, OutputIterator dest)
           if(p.first.empty()) {
             continue;
           }
-          *dest_++ = SharedHandle<Peer>(new Peer(p.first, p.second));
+          *dest_++ = std::shared_ptr<Peer>(new Peer(p.first, p.second));
         }
       }
     }
@@ -314,7 +314,7 @@ void extractPeer(const ValueBase* peerData, int family, OutputIterator dest)
         if(!ip || !port || !(0 < port->i() && port->i() < 65536)) {
           continue;
         }
-        *dest_ = SharedHandle<Peer>(new Peer(ip->s(), port->i()));
+        *dest_ = std::shared_ptr<Peer>(new Peer(ip->s(), port->i()));
         ++dest_;
       }
     }
@@ -329,7 +329,7 @@ void extractPeer(const ValueBase* peerData, int family, OutputIterator dest)
 
 template<typename OutputIterator>
 void extractPeer
-(const SharedHandle<ValueBase>& peerData, int family, OutputIterator dest)
+(const std::shared_ptr<ValueBase>& peerData, int family, OutputIterator dest)
 {
   return extractPeer(peerData.get(), family, dest);
 }
@@ -341,9 +341,9 @@ const char* getModeString(BtFileMode mode);
 
 // Writes the detailed information about torrent loaded in dctx.
 template<typename Output>
-void print(Output& o, const SharedHandle<DownloadContext>& dctx)
+void print(Output& o, const std::shared_ptr<DownloadContext>& dctx)
 {
-  SharedHandle<TorrentAttribute> torrentAttrs = getTorrentAttrs(dctx);
+  std::shared_ptr<TorrentAttribute> torrentAttrs = getTorrentAttrs(dctx);
   o.write("*** BitTorrent File Information ***\n");
   if(!torrentAttrs->comment.empty()) {
     o.printf("Comment: %s\n", torrentAttrs->comment.c_str());
diff --git a/src/console.h b/src/console.h
index 8b99f7f1..ac138765 100644
--- a/src/console.h
+++ b/src/console.h
@@ -36,12 +36,14 @@
 #define D_CONSOLE_H
 
 #include "common.h"
-#include "SharedHandle.h"
+
+#include <memory>
+
 #include "OutputFile.h"
 
 namespace aria2 {
 
-typedef SharedHandle<OutputFile> Console;
+typedef std::shared_ptr<OutputFile> Console;
 
 namespace global {
 
diff --git a/src/download_helper.cc b/src/download_helper.cc
index 7ac72a98..cfed2c8a 100644
--- a/src/download_helper.cc
+++ b/src/download_helper.cc
@@ -106,9 +106,9 @@ void splitURI(std::vector<std::string>& result,
 } // namespace
 
 namespace {
-SharedHandle<GroupId> getGID(const SharedHandle<Option>& option)
+std::shared_ptr<GroupId> getGID(const std::shared_ptr<Option>& option)
 {
-  SharedHandle<GroupId> gid;
+  std::shared_ptr<GroupId> gid;
   if(option->defined(PREF_GID)) {
     a2_gid_t n;
     if(GroupId::toNumericId(n, option->get(PREF_GID).c_str()) != 0) {
@@ -128,14 +128,14 @@ SharedHandle<GroupId> getGID(const SharedHandle<Option>& option)
 } // namespace
 
 namespace {
-SharedHandle<RequestGroup> createRequestGroup
-(const SharedHandle<Option>& optionTemplate,
+std::shared_ptr<RequestGroup> createRequestGroup
+(const std::shared_ptr<Option>& optionTemplate,
  const std::vector<std::string>& uris,
  bool useOutOption = false)
 {
-  SharedHandle<Option> option = util::copy(optionTemplate);
-  SharedHandle<RequestGroup> rg(new RequestGroup(getGID(option), option));
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<Option> option = util::copy(optionTemplate);
+  std::shared_ptr<RequestGroup> rg(new RequestGroup(getGID(option), option));
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext
      (option->getAsInt(PREF_PIECE_LENGTH),
       0,
@@ -165,17 +165,17 @@ SharedHandle<RequestGroup> createRequestGroup
 
 #if defined ENABLE_BITTORRENT || ENABLE_METALINK
 namespace {
-SharedHandle<MetadataInfo> createMetadataInfo(const SharedHandle<GroupId>& gid,
+std::shared_ptr<MetadataInfo> createMetadataInfo(const std::shared_ptr<GroupId>& gid,
                                               const std::string& uri)
 {
-  return SharedHandle<MetadataInfo>(new MetadataInfo(gid, uri));
+  return std::shared_ptr<MetadataInfo>(new MetadataInfo(gid, uri));
 }
 } // namespace
 
 namespace {
-SharedHandle<MetadataInfo> createMetadataInfoDataOnly()
+std::shared_ptr<MetadataInfo> createMetadataInfoDataOnly()
 {
-  return SharedHandle<MetadataInfo>(new MetadataInfo());
+  return std::shared_ptr<MetadataInfo>(new MetadataInfo());
 }
 } // namespace
 #endif // ENABLE_BITTORRENT || ENABLE_METALINK
@@ -183,17 +183,17 @@ SharedHandle<MetadataInfo> createMetadataInfoDataOnly()
 #ifdef ENABLE_BITTORRENT
 
 namespace {
-SharedHandle<RequestGroup>
+std::shared_ptr<RequestGroup>
 createBtRequestGroup(const std::string& metaInfoUri,
-                     const SharedHandle<Option>& optionTemplate,
+                     const std::shared_ptr<Option>& optionTemplate,
                      const std::vector<std::string>& auxUris,
-                     const SharedHandle<ValueBase>& torrent,
+                     const std::shared_ptr<ValueBase>& torrent,
                      bool adjustAnnounceUri = true)
 {
-  SharedHandle<Option> option = util::copy(optionTemplate);
-  SharedHandle<GroupId> gid = getGID(option);
-  SharedHandle<RequestGroup> rg(new RequestGroup(gid, option));
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<Option> option = util::copy(optionTemplate);
+  std::shared_ptr<GroupId> gid = getGID(option);
+  std::shared_ptr<RequestGroup> rg(new RequestGroup(gid, option));
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   // may throw exception
   bittorrent::loadFromMemory(torrent, dctx, option, auxUris,
                              metaInfoUri.empty() ? "default" : metaInfoUri);
@@ -228,15 +228,15 @@ createBtRequestGroup(const std::string& metaInfoUri,
 } // namespace
 
 namespace {
-SharedHandle<RequestGroup>
+std::shared_ptr<RequestGroup>
 createBtMagnetRequestGroup
 (const std::string& magnetLink,
- const SharedHandle<Option>& optionTemplate)
+ const std::shared_ptr<Option>& optionTemplate)
 {
-  SharedHandle<Option> option = util::copy(optionTemplate);
-  SharedHandle<GroupId> gid = getGID(option);
-  SharedHandle<RequestGroup> rg(new RequestGroup(gid, option));
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<Option> option = util::copy(optionTemplate);
+  std::shared_ptr<GroupId> gid = getGID(option);
+  std::shared_ptr<RequestGroup> rg(new RequestGroup(gid, option));
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(METADATA_PIECE_SIZE, 0,
                          A2STR::NIL));
   // We only know info hash. Total Length is unknown at this moment.
@@ -244,17 +244,17 @@ createBtMagnetRequestGroup
   rg->setFileAllocationEnabled(false);
   rg->setPreLocalFileCheckEnabled(false);
   bittorrent::loadMagnet(magnetLink, dctx);
-  SharedHandle<TorrentAttribute> torrentAttrs =
+  std::shared_ptr<TorrentAttribute> torrentAttrs =
     bittorrent::getTorrentAttrs(dctx);
   bittorrent::adjustAnnounceUri(torrentAttrs, option);
   dctx->getFirstFileEntry()->setPath(torrentAttrs->name);
   rg->setDownloadContext(dctx);
   rg->clearPostDownloadHandler();
-  SharedHandle<UTMetadataPostDownloadHandler> utMetadataPostHandler
+  std::shared_ptr<UTMetadataPostDownloadHandler> utMetadataPostHandler
     (new UTMetadataPostDownloadHandler());
   rg->addPostDownloadHandler(utMetadataPostHandler);
   rg->setDiskWriterFactory
-    (SharedHandle<DiskWriterFactory>(new ByteArrayDiskWriterFactory()));
+    (std::shared_ptr<DiskWriterFactory>(new ByteArrayDiskWriterFactory()));
   rg->setMetadataInfo(createMetadataInfo(gid, magnetLink));
   rg->markInMemoryDownload();
   rg->setPauseRequested(option->getAsBool(PREF_PAUSE));
@@ -264,14 +264,14 @@ createBtMagnetRequestGroup
 } // namespace
 
 void createRequestGroupForBitTorrent
-(std::vector<SharedHandle<RequestGroup> >& result,
- const SharedHandle<Option>& option,
+(std::vector<std::shared_ptr<RequestGroup> >& result,
+ const std::shared_ptr<Option>& option,
  const std::vector<std::string>& uris,
  const std::string& metaInfoUri,
  const std::string& torrentData,
  bool adjustAnnounceUri)
 {
-  SharedHandle<ValueBase> torrent;
+  std::shared_ptr<ValueBase> torrent;
   bittorrent::ValueBaseBencodeParser parser;
   if(torrentData.empty()) {
     torrent = parseFile(parser, metaInfoUri);
@@ -288,11 +288,11 @@ void createRequestGroupForBitTorrent
 }
 
 void createRequestGroupForBitTorrent
-(std::vector<SharedHandle<RequestGroup> >& result,
- const SharedHandle<Option>& option,
+(std::vector<std::shared_ptr<RequestGroup> >& result,
+ const std::shared_ptr<Option>& option,
  const std::vector<std::string>& uris,
  const std::string& metaInfoUri,
- const SharedHandle<ValueBase>& torrent,
+ const std::shared_ptr<ValueBase>& torrent,
  bool adjustAnnounceUri)
 {
   std::vector<std::string> nargs;
@@ -303,7 +303,7 @@ void createRequestGroupForBitTorrent
   }
   // we ignore -Z option here
   size_t numSplit = option->getAsInt(PREF_SPLIT);
-  SharedHandle<RequestGroup> rg =
+  std::shared_ptr<RequestGroup> rg =
     createBtRequestGroup(metaInfoUri, option, nargs,
                          torrent, adjustAnnounceUri);
   rg->setNumConcurrentCommand(numSplit);
@@ -314,8 +314,8 @@ void createRequestGroupForBitTorrent
 
 #ifdef ENABLE_METALINK
 void createRequestGroupForMetalink
-(std::vector<SharedHandle<RequestGroup> >& result,
- const SharedHandle<Option>& option,
+(std::vector<std::shared_ptr<RequestGroup> >& result,
+ const std::shared_ptr<Option>& option,
  const std::string& metalinkData)
 {
   if(metalinkData.empty()) {
@@ -324,7 +324,7 @@ void createRequestGroupForMetalink
                                      option,
                                      option->get(PREF_METALINK_BASE_URI));
   } else {
-    SharedHandle<ByteArrayDiskWriter> dw(new ByteArrayDiskWriter());
+    std::shared_ptr<ByteArrayDiskWriter> dw(new ByteArrayDiskWriter());
     dw->setString(metalinkData);
     Metalink2RequestGroup().generate(result, dw, option,
                                      option->get(PREF_METALINK_BASE_URI));
@@ -335,14 +335,14 @@ void createRequestGroupForMetalink
 namespace {
 class AccRequestGroup {
 private:
-  std::vector<SharedHandle<RequestGroup> >& requestGroups_;
+  std::vector<std::shared_ptr<RequestGroup> >& requestGroups_;
   ProtocolDetector detector_;
-  SharedHandle<Option> option_;
+  std::shared_ptr<Option> option_;
   bool ignoreLocalPath_;
   bool throwOnError_;
 public:
-  AccRequestGroup(std::vector<SharedHandle<RequestGroup> >& requestGroups,
-                  const SharedHandle<Option>& option,
+  AccRequestGroup(std::vector<std::shared_ptr<RequestGroup> >& requestGroups,
+                  const std::shared_ptr<Option>& option,
                   bool ignoreLocalPath = false,
                   bool throwOnError = false):
     requestGroups_(requestGroups), option_(option),
@@ -361,19 +361,19 @@ public:
       for(size_t i = 0; i < num; ++i) {
         streamURIs.push_back(uri);
       }
-      SharedHandle<RequestGroup> rg = createRequestGroup(option_, streamURIs);
+      std::shared_ptr<RequestGroup> rg = createRequestGroup(option_, streamURIs);
       rg->setNumConcurrentCommand(numSplit);
       requestGroups_.push_back(rg);
     }
 #ifdef ENABLE_BITTORRENT
     else if(detector_.guessTorrentMagnet(uri)) {
-      SharedHandle<RequestGroup> group =
+      std::shared_ptr<RequestGroup> group =
         createBtMagnetRequestGroup(uri, option_);
       requestGroups_.push_back(group);
     } else if(!ignoreLocalPath_ && detector_.guessTorrentFile(uri)) {
       try {
         bittorrent::ValueBaseBencodeParser parser;
-        SharedHandle<ValueBase> torrent = parseFile(parser, uri);
+        std::shared_ptr<ValueBase> torrent = parseFile(parser, uri);
         if(!torrent) {
           throw DL_ABORT_EX2("Bencode decoding failed",
                              error_code::BENCODE_PARSE_ERROR);
@@ -431,8 +431,8 @@ public:
 } // namespace
 
 void createRequestGroupForUri
-(std::vector<SharedHandle<RequestGroup> >& result,
- const SharedHandle<Option>& option,
+(std::vector<std::shared_ptr<RequestGroup> >& result,
+ const std::shared_ptr<Option>& option,
  const std::vector<std::string>& uris,
  bool ignoreForceSequential,
  bool ignoreLocalPath,
@@ -458,7 +458,7 @@ void createRequestGroupForUri
       std::vector<std::string> streamURIs;
       splitURI(streamURIs, nargs.begin(), strmProtoEnd, numSplit, numIter);
       try {
-        SharedHandle<RequestGroup> rg =
+        std::shared_ptr<RequestGroup> rg =
           createRequestGroup(option, streamURIs, true);
         rg->setNumConcurrentCommand(numSplit);
         result.push_back(rg);
@@ -478,7 +478,7 @@ void createRequestGroupForUri
 }
 
 bool createRequestGroupFromUriListParser
-(std::vector<SharedHandle<RequestGroup> >& result,
+(std::vector<std::shared_ptr<RequestGroup> >& result,
  const Option* option,
  UriListParser* uriListParser)
 {
@@ -493,9 +493,9 @@ bool createRequestGroupFromUriListParser
     if(uris.empty()) {
       continue;
     }
-    SharedHandle<Option> requestOption(new Option(*option));
+    std::shared_ptr<Option> requestOption(new Option(*option));
     requestOption->remove(PREF_OUT);
-    const SharedHandle<OptionParser>& oparser = OptionParser::getInstance();
+    const std::shared_ptr<OptionParser>& oparser = OptionParser::getInstance();
     for(size_t i = 1, len = option::countOption(); i < len; ++i) {
       const Pref* pref = option::i2p(i);
       const OptionHandler* h = oparser->find(pref);
@@ -512,7 +512,7 @@ bool createRequestGroupFromUriListParser
   return false;
 }
 
-SharedHandle<UriListParser> openUriListParser(const std::string& filename)
+std::shared_ptr<UriListParser> openUriListParser(const std::string& filename)
 {
   std::string listPath;
   if(filename == "-") {
@@ -524,36 +524,36 @@ SharedHandle<UriListParser> openUriListParser(const std::string& filename)
     }
     listPath = filename;
   }
-  return SharedHandle<UriListParser>(new UriListParser(listPath));
+  return std::shared_ptr<UriListParser>(new UriListParser(listPath));
 }
 
 void createRequestGroupForUriList
-(std::vector<SharedHandle<RequestGroup> >& result,
- const SharedHandle<Option>& option)
+(std::vector<std::shared_ptr<RequestGroup> >& result,
+ const std::shared_ptr<Option>& option)
 {
-  SharedHandle<UriListParser> uriListParser = openUriListParser
+  std::shared_ptr<UriListParser> uriListParser = openUriListParser
     (option->get(PREF_INPUT_FILE));
   while(createRequestGroupFromUriListParser(result, option.get(),
                                             uriListParser.get()));
 }
 
-SharedHandle<MetadataInfo>
-createMetadataInfoFromFirstFileEntry(const SharedHandle<GroupId>& gid,
-                                     const SharedHandle<DownloadContext>& dctx)
+std::shared_ptr<MetadataInfo>
+createMetadataInfoFromFirstFileEntry(const std::shared_ptr<GroupId>& gid,
+                                     const std::shared_ptr<DownloadContext>& dctx)
 {
   if(dctx->getFileEntries().empty()) {
-    return SharedHandle<MetadataInfo>();
+    return std::shared_ptr<MetadataInfo>();
   } else {
     std::vector<std::string> uris;
     dctx->getFileEntries()[0]->getUris(uris);
     if(uris.empty()) {
-      return SharedHandle<MetadataInfo>();
+      return std::shared_ptr<MetadataInfo>();
     }
-    return SharedHandle<MetadataInfo>(new MetadataInfo(gid, uris[0]));
+    return std::shared_ptr<MetadataInfo>(new MetadataInfo(gid, uris[0]));
   }
 }
 
-void removeOneshotOption(const SharedHandle<Option>& option)
+void removeOneshotOption(const std::shared_ptr<Option>& option)
 {
   option->remove(PREF_PAUSE);
   option->remove(PREF_GID);
diff --git a/src/download_helper.h b/src/download_helper.h
index 7a7fcd01..6289c481 100644
--- a/src/download_helper.h
+++ b/src/download_helper.h
@@ -40,8 +40,7 @@
 #include <string>
 #include <vector>
 #include <set>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -61,8 +60,8 @@ class GroupId;
 // adjusted using bittorrent::adjustAnnounceUri().  In this function,
 // force-sequential is ignored.
 void createRequestGroupForBitTorrent
-(std::vector<SharedHandle<RequestGroup> >& result,
- const SharedHandle<Option>& option,
+(std::vector<std::shared_ptr<RequestGroup> >& result,
+ const std::shared_ptr<Option>& option,
  const std::vector<std::string>& uris,
  const std::string& metaInfoUri,
  const std::string& torrentData = "",
@@ -73,11 +72,11 @@ void createRequestGroupForBitTorrent
 // adjusted using bittorrent::adjustAnnounceUri().  In this function,
 // force-sequential is ignored.
 void createRequestGroupForBitTorrent
-(std::vector<SharedHandle<RequestGroup> >& result,
- const SharedHandle<Option>& option,
+(std::vector<std::shared_ptr<RequestGroup> >& result,
+ const std::shared_ptr<Option>& option,
  const std::vector<std::string>& uris,
  const std::string& metaInfoUri,
- const SharedHandle<ValueBase>& torrent,
+ const std::shared_ptr<ValueBase>& torrent,
  bool adjustAnnounceUri = true);
 
 #endif // ENABLE_BITTORRENT
@@ -87,8 +86,8 @@ void createRequestGroupForBitTorrent
 // metalink-file option. If non-empty metalinkData is specified, it is
 // used as a content of metalink file instead.
 void createRequestGroupForMetalink
-(std::vector<SharedHandle<RequestGroup> >& result,
- const SharedHandle<Option>& option,
+(std::vector<std::shared_ptr<RequestGroup> >& result,
+ const std::shared_ptr<Option>& option,
  const std::string& metalinkData = "");
 #endif // ENABLE_METALINK
 
@@ -100,7 +99,7 @@ void createRequestGroupForMetalink
 // is created and uriListParser reads all input, this function returns
 // false. The option is used as a option template.
 bool createRequestGroupFromUriListParser
-(std::vector<SharedHandle<RequestGroup> >& result,
+(std::vector<std::shared_ptr<RequestGroup> >& result,
  const Option* option,
  UriListParser* uriListParser);
 
@@ -108,9 +107,9 @@ bool createRequestGroupFromUriListParser
 // then UriListParser is configured to read from standard input.
 // Otherwise, this function first checks file denoted by filename
 // exists.  If it does not exist, this function throws exception.
-// This function returns SharedHandle<UriListParser> object if it
+// This function returns std::shared_ptr<UriListParser> object if it
 // succeeds.
-SharedHandle<UriListParser> openUriListParser(const std::string& filename);
+std::shared_ptr<UriListParser> openUriListParser(const std::string& filename);
 
 // Create RequestGroup objects from reading file specified by input-file option.
 // If the value of input-file option is "-", stdin is used as a input source.
@@ -118,8 +117,8 @@ SharedHandle<UriListParser> openUriListParser(const std::string& filename);
 // The additional out and dir options can be specified after each line of URIs.
 // This optional line must start with white space(s).
 void createRequestGroupForUriList
-(std::vector<SharedHandle<RequestGroup> >& result,
- const SharedHandle<Option>& option);
+(std::vector<std::shared_ptr<RequestGroup> >& result,
+ const std::shared_ptr<Option>& option);
 
 // Create RequestGroup object using provided uris.  If ignoreLocalPath
 // is true, a path to torrent file abd metalink file are ignored.  If
@@ -128,8 +127,8 @@ void createRequestGroupForUriList
 // given. If throwOnError is false, these errors are just logged as
 // error.
 void createRequestGroupForUri
-(std::vector<SharedHandle<RequestGroup> >& result,
- const SharedHandle<Option>& option,
+(std::vector<std::shared_ptr<RequestGroup> >& result,
+ const std::shared_ptr<Option>& option,
  const std::vector<std::string>& uris,
  bool ignoreForceSequential = false,
  bool ignoreLocalPath = false,
@@ -137,20 +136,20 @@ void createRequestGroupForUri
 
 template<typename InputIterator>
 void setMetadataInfo
-(InputIterator first, InputIterator last, const SharedHandle<MetadataInfo>& mi)
+(InputIterator first, InputIterator last, const std::shared_ptr<MetadataInfo>& mi)
 {
   for(; first != last; ++first) {
     (*first)->setMetadataInfo(mi);
   }
 }
 
-SharedHandle<MetadataInfo>
-createMetadataInfoFromFirstFileEntry(const SharedHandle<GroupId>& gid,
-                                     const SharedHandle<DownloadContext>& dctx);
+std::shared_ptr<MetadataInfo>
+createMetadataInfoFromFirstFileEntry(const std::shared_ptr<GroupId>& gid,
+                                     const std::shared_ptr<DownloadContext>& dctx);
 
 // Removes option value which is only effective at the first
 // construction time.
-void removeOneshotOption(const SharedHandle<Option>& option);
+void removeOneshotOption(const std::shared_ptr<Option>& option);
 
 } // namespace aria2
 
diff --git a/src/json.cc b/src/json.cc
index 78463fc3..131b9755 100644
--- a/src/json.cc
+++ b/src/json.cc
@@ -85,7 +85,7 @@ std::string jsonEscape(const std::string& s)
 }
 
 // Serializes JSON object or array.
-std::string encode(const SharedHandle<ValueBase>& json)
+std::string encode(const std::shared_ptr<ValueBase>& json)
 {
   std::ostringstream out;
   return encode(out, json.get()).str();
diff --git a/src/json.h b/src/json.h
index 7056dfec..fa2e07ee 100644
--- a/src/json.h
+++ b/src/json.h
@@ -118,13 +118,13 @@ OutputStream& encode(OutputStream& out, const ValueBase* vlb)
 }
 
 template<typename OutputStream>
-OutputStream& encode(OutputStream& out, const SharedHandle<ValueBase>& vlb)
+OutputStream& encode(OutputStream& out, const std::shared_ptr<ValueBase>& vlb)
 {
   return encode(out, vlb.get());
 }
 
 // Serializes JSON object or array.
-std::string encode(const SharedHandle<ValueBase>& json);
+std::string encode(const std::shared_ptr<ValueBase>& json);
 
 struct JsonGetParam {
   std::string request;
diff --git a/src/magnet.cc b/src/magnet.cc
index fb6c0aa5..31f404e8 100644
--- a/src/magnet.cc
+++ b/src/magnet.cc
@@ -40,9 +40,9 @@ namespace aria2 {
 
 namespace magnet {
 
-SharedHandle<Dict> parse(const std::string& magnet)
+std::shared_ptr<Dict> parse(const std::string& magnet)
 {
-  SharedHandle<Dict> dict;
+  std::shared_ptr<Dict> dict;
   if(!util::startsWith(magnet, "magnet:?")) {
     return dict;
   }
@@ -60,7 +60,7 @@ SharedHandle<Dict> parse(const std::string& magnet)
     if(l) {
       l->append(String::g(value));
     } else {
-      SharedHandle<List> l = List::g();
+      std::shared_ptr<List> l = List::g();
       l->append(String::g(value));
       dict->put(name, l);
     }
diff --git a/src/magnet.h b/src/magnet.h
index d2de23c7..4cb34246 100644
--- a/src/magnet.h
+++ b/src/magnet.h
@@ -43,11 +43,11 @@ namespace aria2 {
 namespace magnet {
 
 // Parses Magnet URI magnet and stores parameters in
-// SharedHandle<Dict>.  Because same parameter name can appear more
-// than once, the value associated with a key is SharedHandle<List>. A
+// std::shared_ptr<Dict>.  Because same parameter name can appear more
+// than once, the value associated with a key is std::shared_ptr<List>. A
 // parameter value is stored in a list. If parsing operation failed,
-// SharedHandle<Dict>() is returned.
-SharedHandle<Dict> parse(const std::string& magnet);
+// std::shared_ptr<Dict>() is returned.
+std::shared_ptr<Dict> parse(const std::string& magnet);
 
 } // namespace magnet
 
diff --git a/src/main.cc b/src/main.cc
index 3bb11889..f2be6c59 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -37,7 +37,6 @@
 #include <unistd.h>
 
 #include <aria2/aria2.h>
-#include "SharedHandle.h"
 #include "Context.h"
 #include "MultiUrlRequestInfo.h"
 #include "message.h"
diff --git a/src/message_digest_helper.cc b/src/message_digest_helper.cc
index 95705fb6..2f1eb2f6 100644
--- a/src/message_digest_helper.cc
+++ b/src/message_digest_helper.cc
@@ -49,8 +49,8 @@ namespace aria2 {
 namespace message_digest {
 
 std::string digest
-(const SharedHandle<MessageDigest>& ctx,
- const SharedHandle<BinaryStream>& bs,
+(const std::shared_ptr<MessageDigest>& ctx,
+ const std::shared_ptr<BinaryStream>& bs,
  int64_t offset, int64_t length)
 {
   size_t BUFSIZE = 4096;
@@ -78,7 +78,7 @@ std::string digest
 
 void digest
 (unsigned char* md, size_t mdLength,
- const SharedHandle<MessageDigest>& ctx, const void* data, size_t length)
+ const std::shared_ptr<MessageDigest>& ctx, const void* data, size_t length)
 {
   size_t reqLength = ctx->getDigestLength();
   if(mdLength < reqLength) {
diff --git a/src/message_digest_helper.h b/src/message_digest_helper.h
index aa7f4a09..9a05eecf 100644
--- a/src/message_digest_helper.h
+++ b/src/message_digest_helper.h
@@ -38,8 +38,7 @@
 #include "common.h"
 
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -53,8 +52,8 @@ namespace message_digest {
  * Returns raw digest string, not hex digest
  */
 std::string digest
-(const SharedHandle<MessageDigest>& ctx,
- const SharedHandle<BinaryStream>& bs,
+(const std::shared_ptr<MessageDigest>& ctx,
+ const std::shared_ptr<BinaryStream>& bs,
  int64_t offset, int64_t length);
 
 /**
@@ -63,7 +62,7 @@ std::string digest
  */
 void digest
 (unsigned char* md, size_t mdLength,
- const SharedHandle<MessageDigest>& ctx,
+ const std::shared_ptr<MessageDigest>& ctx,
  const void* data, size_t length);
 
 } // namespace message_digest
diff --git a/src/metalink_helper.cc b/src/metalink_helper.cc
index c6db06c2..3f70ae5f 100644
--- a/src/metalink_helper.cc
+++ b/src/metalink_helper.cc
@@ -50,8 +50,8 @@ namespace metalink {
 namespace {
 
 void query
-(std::vector<SharedHandle<MetalinkEntry> >& result,
- const SharedHandle<Metalinker>& metalinker,
+(std::vector<std::shared_ptr<MetalinkEntry> >& result,
+ const std::shared_ptr<Metalinker>& metalinker,
  const Option* option)
 {
   metalinker->queryEntry(result,
@@ -63,40 +63,40 @@ void query
 } // namespace
 
 void parseAndQuery
-(std::vector<SharedHandle<MetalinkEntry> >& result,
+(std::vector<std::shared_ptr<MetalinkEntry> >& result,
  const std::string& filename,
  const Option* option,
  const std::string& baseUri)
 {
-  SharedHandle<Metalinker> metalinker = parseFile(filename, baseUri);
+  std::shared_ptr<Metalinker> metalinker = parseFile(filename, baseUri);
   query(result, metalinker, option);
 }
 
 void parseAndQuery
-(std::vector<SharedHandle<MetalinkEntry> >& result,
+(std::vector<std::shared_ptr<MetalinkEntry> >& result,
  BinaryStream* bs,
  const Option* option,
  const std::string& baseUri)
 {
-  SharedHandle<Metalinker> metalinker = parseBinaryStream(bs, baseUri);
+  std::shared_ptr<Metalinker> metalinker = parseBinaryStream(bs, baseUri);
   query(result, metalinker, option);
 }
 
 void groupEntryByMetaurlName
 (std::vector<
-  std::pair<std::string, std::vector<SharedHandle<MetalinkEntry> > > >& result,
- const std::vector<SharedHandle<MetalinkEntry> >& entries)
+  std::pair<std::string, std::vector<std::shared_ptr<MetalinkEntry> > > >& result,
+ const std::vector<std::shared_ptr<MetalinkEntry> >& entries)
 {
-  for(std::vector<SharedHandle<MetalinkEntry> >::const_iterator eiter =
+  for(std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator eiter =
         entries.begin(), eoi = entries.end(); eiter != eoi; ++eiter) {
     if((*eiter)->metaurls.empty()) {
-      std::pair<std::string, std::vector<SharedHandle<MetalinkEntry> > > p;
+      std::pair<std::string, std::vector<std::shared_ptr<MetalinkEntry> > > p;
       p.second.push_back(*eiter);
       result.push_back(p);
     } else {
       std::vector<
       std::pair<std::string,
-        std::vector<SharedHandle<MetalinkEntry> > > >::iterator i =
+        std::vector<std::shared_ptr<MetalinkEntry> > > >::iterator i =
         result.begin();
       if((*eiter)->metaurls[0]->name.empty() ||
          !(*eiter)->sizeKnown) {
@@ -110,7 +110,7 @@ void groupEntryByMetaurlName
         }
       }
       if(i == result.end()) {
-        std::pair<std::string, std::vector<SharedHandle<MetalinkEntry> > > p;
+        std::pair<std::string, std::vector<std::shared_ptr<MetalinkEntry> > > p;
         p.first = (*eiter)->metaurls[0]->url;
         p.second.push_back(*eiter);
         result.push_back(p);
@@ -119,7 +119,7 @@ void groupEntryByMetaurlName
   }
 }
 
-SharedHandle<Metalinker> parseFile
+std::shared_ptr<Metalinker> parseFile
 (const std::string& filename,
  const std::string& baseUri)
 {
@@ -136,7 +136,7 @@ SharedHandle<Metalinker> parseFile
   return psm.getResult();
 }
 
-SharedHandle<Metalinker> parseBinaryStream
+std::shared_ptr<Metalinker> parseBinaryStream
 (BinaryStream* bs,
  const std::string& baseUri)
 {
diff --git a/src/metalink_helper.h b/src/metalink_helper.h
index f07752bd..875733be 100644
--- a/src/metalink_helper.h
+++ b/src/metalink_helper.h
@@ -39,8 +39,8 @@
 
 #include <string>
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "A2STR.h"
 
 namespace aria2 {
@@ -53,27 +53,27 @@ class Metalinker;
 namespace metalink {
 
 void parseAndQuery
-(std::vector<SharedHandle<MetalinkEntry> >& result,
+(std::vector<std::shared_ptr<MetalinkEntry> >& result,
  const std::string& filename,
  const Option* option,
  const std::string& baseUri = A2STR::NIL);
 
 void parseAndQuery
-(std::vector<SharedHandle<MetalinkEntry> >& result,
+(std::vector<std::shared_ptr<MetalinkEntry> >& result,
  BinaryStream* bs,
  const Option* option,
  const std::string& baseUri = A2STR::NIL);
 
 void groupEntryByMetaurlName
 (std::vector<
-  std::pair<std::string, std::vector<SharedHandle<MetalinkEntry> > > >& result,
- const std::vector<SharedHandle<MetalinkEntry> >& entries);
+  std::pair<std::string, std::vector<std::shared_ptr<MetalinkEntry> > > >& result,
+ const std::vector<std::shared_ptr<MetalinkEntry> >& entries);
 
-SharedHandle<Metalinker> parseFile
+std::shared_ptr<Metalinker> parseFile
 (const std::string& filename,
  const std::string& baseUri = A2STR::NIL);
 
-SharedHandle<Metalinker> parseBinaryStream
+std::shared_ptr<Metalinker> parseBinaryStream
 (BinaryStream* bs,
  const std::string& baseUri = A2STR::NIL);
 
diff --git a/src/option_processing.cc b/src/option_processing.cc
index d93dff02..dc2e3bbd 100644
--- a/src/option_processing.cc
+++ b/src/option_processing.cc
@@ -68,13 +68,13 @@ namespace aria2 {
 extern void showVersion();
 extern void showUsage
 (const std::string& keyword,
- const SharedHandle<OptionParser>& oparser,
+ const std::shared_ptr<OptionParser>& oparser,
  const Console& out);
 
 namespace {
 void overrideWithEnv
 (Option& op,
- const SharedHandle<OptionParser>& optionParser,
+ const std::shared_ptr<OptionParser>& optionParser,
  const Pref* pref,
  const std::string& envName)
 {
@@ -131,7 +131,7 @@ int levenshtein
 namespace {
 
 void showCandidates
-(const std::string& unknownOption, const SharedHandle<OptionParser>& parser)
+(const std::string& unknownOption, const std::shared_ptr<OptionParser>& parser)
 {
   const char* optstr = unknownOption.c_str();
   for(; *optstr == '-'; ++optstr);
@@ -195,7 +195,7 @@ error_code::Value option_processing(Option& op, bool standalone,
                                     int argc, char** argv,
                                     const KeyVals& options)
 {
-  const SharedHandle<OptionParser>& oparser = OptionParser::getInstance();
+  const std::shared_ptr<OptionParser>& oparser = OptionParser::getInstance();
   try {
     bool noConf = false;
     std::string ucfname;
@@ -231,7 +231,7 @@ error_code::Value option_processing(Option& op, bool standalone,
         }
       }
     }
-    SharedHandle<Option> confOption(new Option());
+    std::shared_ptr<Option> confOption(new Option());
     oparser->parseDefaultValues(*confOption);
     if(!noConf) {
       std::string cfname =
diff --git a/src/rpc_helper.cc b/src/rpc_helper.cc
index 2d5b1ef0..8b372908 100644
--- a/src/rpc_helper.cc
+++ b/src/rpc_helper.cc
@@ -56,9 +56,9 @@ RpcRequest xmlParseMemory(const char* xml, size_t size)
   if(xml::XmlParser(&psm).parseFinal(xml, size) < 0) {
     throw DL_ABORT_EX(MSG_CANNOT_PARSE_XML_RPC_REQUEST);
   }
-  SharedHandle<List> params;
+  std::shared_ptr<List> params;
   if(downcast<List>(psm.getCurrentFrameValue())) {
-    params = static_pointer_cast<List>(psm.getCurrentFrameValue());
+    params = std::static_pointer_cast<List>(psm.getCurrentFrameValue());
   } else {
     params = List::g();
   }
@@ -68,9 +68,9 @@ RpcRequest xmlParseMemory(const char* xml, size_t size)
 
 RpcResponse createJsonRpcErrorResponse(int code,
                                        const std::string& msg,
-                                       const SharedHandle<ValueBase>& id)
+                                       const std::shared_ptr<ValueBase>& id)
 {
-  SharedHandle<Dict> params = Dict::g();
+  std::shared_ptr<Dict> params = Dict::g();
   params->put("code", Integer::g(code));
   params->put("message", msg);
   rpc::RpcResponse res(code, params, id);
@@ -79,7 +79,7 @@ RpcResponse createJsonRpcErrorResponse(int code,
 
 RpcResponse processJsonRpcRequest(const Dict* jsondict, DownloadEngine* e)
 {
-  SharedHandle<ValueBase> id = jsondict->get("id");
+  std::shared_ptr<ValueBase> id = jsondict->get("id");
   if(!id) {
     return createJsonRpcErrorResponse(-32600, "Invalid Request.", Null::g());
   }
@@ -87,10 +87,10 @@ RpcResponse processJsonRpcRequest(const Dict* jsondict, DownloadEngine* e)
   if(!methodName) {
     return createJsonRpcErrorResponse(-32600, "Invalid Request.", id);
   }
-  SharedHandle<List> params;
-  const SharedHandle<ValueBase>& tempParams = jsondict->get("params");
+  std::shared_ptr<List> params;
+  const std::shared_ptr<ValueBase>& tempParams = jsondict->get("params");
   if(downcast<List>(tempParams)) {
-    params = static_pointer_cast<List>(tempParams);
+    params = std::static_pointer_cast<List>(tempParams);
   } else if(!tempParams) {
     params = List::g();
   } else {
@@ -99,7 +99,7 @@ RpcResponse processJsonRpcRequest(const Dict* jsondict, DownloadEngine* e)
   }
   rpc::RpcRequest req(methodName->s(), params, id);
   req.jsonRpc = true;
-  SharedHandle<rpc::RpcMethod> method;
+  std::shared_ptr<rpc::RpcMethod> method;
   try {
     method = rpc::RpcMethodFactory::create(req.methodName);
   } catch(RecoverableException& e) {
diff --git a/src/rpc_helper.h b/src/rpc_helper.h
index 4747a033..50e4595e 100644
--- a/src/rpc_helper.h
+++ b/src/rpc_helper.h
@@ -39,8 +39,7 @@
 
 #include <cstdlib>
 #include <string>
-
-#include "SharedHandle.h"
+#include <memory>
 
 namespace aria2 {
 
@@ -61,7 +60,7 @@ RpcRequest xmlParseMemory(const char* xml, size_t size);
 // |msg| is the error message. The |id| is the id of the request .
 RpcResponse createJsonRpcErrorResponse(int code,
                                        const std::string& msg,
-                                       const SharedHandle<ValueBase>& id);
+                                       const std::shared_ptr<ValueBase>& id);
 
 // Processes JSON-RPC request |jsondict| and returns the result.
 RpcResponse processJsonRpcRequest(const Dict* jsondict, DownloadEngine* e);
diff --git a/src/util.cc b/src/util.cc
index 3d2a50f6..3eac6c38 100644
--- a/src/util.cc
+++ b/src/util.cc
@@ -656,14 +656,14 @@ void parseIntSegments(SegList<int>& sgl, const std::string& src)
 namespace {
 void computeHeadPieces
 (std::vector<size_t>& indexes,
- const std::vector<SharedHandle<FileEntry> >& fileEntries,
+ const std::vector<std::shared_ptr<FileEntry> >& fileEntries,
  size_t pieceLength,
  int64_t head)
 {
   if(head == 0) {
     return;
   }
-  for(std::vector<SharedHandle<FileEntry> >::const_iterator fi =
+  for(std::vector<std::shared_ptr<FileEntry> >::const_iterator fi =
         fileEntries.begin(), eoi = fileEntries.end(); fi != eoi; ++fi) {
     if((*fi)->getLength() == 0) {
       continue;
@@ -681,14 +681,14 @@ void computeHeadPieces
 namespace {
 void computeTailPieces
 (std::vector<size_t>& indexes,
- const std::vector<SharedHandle<FileEntry> >& fileEntries,
+ const std::vector<std::shared_ptr<FileEntry> >& fileEntries,
  size_t pieceLength,
  int64_t tail)
 {
   if(tail == 0) {
     return;
   }
-  for(std::vector<SharedHandle<FileEntry> >::const_iterator fi =
+  for(std::vector<std::shared_ptr<FileEntry> >::const_iterator fi =
         fileEntries.begin(), eoi = fileEntries.end(); fi != eoi; ++fi) {
     if((*fi)->getLength() == 0) {
       continue;
@@ -706,7 +706,7 @@ void computeTailPieces
 
 void parsePrioritizePieceRange
 (std::vector<size_t>& result, const std::string& src,
- const std::vector<SharedHandle<FileEntry> >& fileEntries,
+ const std::vector<std::shared_ptr<FileEntry> >& fileEntries,
  size_t pieceLength,
  int64_t defaultSize)
 {
@@ -1409,7 +1409,7 @@ void convertBitfield(BitfieldMan* dest, const BitfieldMan* src)
   }
 }
 
-std::string toString(const SharedHandle<BinaryStream>& binaryStream)
+std::string toString(const std::shared_ptr<BinaryStream>& binaryStream)
 {
   std::stringstream strm;
   char data[2048];
@@ -1506,7 +1506,7 @@ std::vector<std::pair<size_t, std::string> > createIndexPaths(std::istream& i)
 namespace {
 void generateRandomDataRandom(unsigned char* data, size_t length)
 {
-  const SharedHandle<SimpleRandomizer>& rd = SimpleRandomizer::getInstance();
+  const std::shared_ptr<SimpleRandomizer>& rd = SimpleRandomizer::getInstance();
   for(size_t i = 0; i < length; ++i) {
     data[i] = static_cast<unsigned long>(rd->getRandomNumber(256));
   }
@@ -1793,7 +1793,7 @@ void executeHook
 } // namespace
 
 void executeHookByOptName
-(const SharedHandle<RequestGroup>& group, const Option* option,
+(const std::shared_ptr<RequestGroup>& group, const Option* option,
  const Pref* pref)
 {
   executeHookByOptName(group.get(), option, pref);
@@ -1804,11 +1804,11 @@ void executeHookByOptName
 {
   const std::string& cmd = option->get(pref);
   if(!cmd.empty()) {
-    const SharedHandle<DownloadContext> dctx = group->getDownloadContext();
+    const std::shared_ptr<DownloadContext> dctx = group->getDownloadContext();
     std::string firstFilename;
     size_t numFiles = 0;
     if(!group->inMemoryDownload()) {
-      SharedHandle<FileEntry> file = dctx->getFirstRequestedFileEntry();
+      std::shared_ptr<FileEntry> file = dctx->getFirstRequestedFileEntry();
       if(file) {
         firstFilename = file->getPath();
       }
diff --git a/src/util.h b/src/util.h
index 4803b7a9..07a40b7d 100644
--- a/src/util.h
+++ b/src/util.h
@@ -52,8 +52,8 @@
 #include <iomanip>
 #include <algorithm>
 #include <vector>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "a2time.h"
 #include "a2netcompat.h"
 #include "a2functional.h"
@@ -296,7 +296,7 @@ void parseIntSegments(SegList<int>& sgl, const std::string& src);
 // sample: head=512K,tail=512K
 void parsePrioritizePieceRange
 (std::vector<size_t>& result, const std::string& src,
- const std::vector<SharedHandle<FileEntry> >& fileEntries,
+ const std::vector<std::shared_ptr<FileEntry> >& fileEntries,
  size_t pieceLength,
  int64_t defaultSize = 1048576 /* 1MiB */);
 
@@ -430,7 +430,7 @@ void mkdirs(const std::string& dirpath);
 void convertBitfield(BitfieldMan* dest, const BitfieldMan* src);
 
 // binaryStream has to be opened before calling this function.
-std::string toString(const SharedHandle<BinaryStream>& binaryStream);
+std::string toString(const std::shared_ptr<BinaryStream>& binaryStream);
 
 #ifdef HAVE_POSIX_MEMALIGN
 void* allocateAlignedMemory(size_t alignment, size_t size);
@@ -784,7 +784,7 @@ bool inSameCidrBlock
 
 // No throw
 void executeHookByOptName
-(const SharedHandle<RequestGroup>& group, const Option* option,
+(const std::shared_ptr<RequestGroup>& group, const Option* option,
  const Pref* pref);
 
 // No throw
@@ -861,9 +861,9 @@ nextParam
 }
 
 template<typename T>
-SharedHandle<T> copy(const SharedHandle<T>& a)
+std::shared_ptr<T> copy(const std::shared_ptr<T>& a)
 {
-  return SharedHandle<T>(new T(*a.get()));
+  return std::shared_ptr<T>(new T(*a.get()));
 }
 
 // This is a bit different from cookie_helper::domainMatch().  If
diff --git a/src/version_usage.cc b/src/version_usage.cc
index a62f9261..c3ad4c89 100644
--- a/src/version_usage.cc
+++ b/src/version_usage.cc
@@ -38,7 +38,6 @@
 #include <iterator>
 #include <algorithm>
 
-#include "SharedHandle.h"
 #include "a2io.h"
 #include "FeatureConfig.h"
 #ifdef ENABLE_MESSAGE_DIGEST
@@ -84,7 +83,7 @@ void showVersion() {
 
 void showUsage
 (const std::string& keyword,
- const SharedHandle<OptionParser>& oparser,
+ const std::shared_ptr<OptionParser>& oparser,
  const Console& out) {
   out->printf(_("Usage: aria2c [OPTIONS] [URI | MAGNET | TORRENT_FILE |"
                 " METALINK_FILE]..."));
diff --git a/test/AnnounceListTest.cc b/test/AnnounceListTest.cc
index 12f5811c..c6325812 100644
--- a/test/AnnounceListTest.cc
+++ b/test/AnnounceListTest.cc
@@ -64,7 +64,7 @@ std::vector<std::vector<std::string> > toVector
 
 void AnnounceListTest::testSingleElementList() {
   std::string peersString = "ll8:tracker1el8:tracker2el8:tracker3ee";
-  SharedHandle<ValueBase> announcesList =
+  std::shared_ptr<ValueBase> announcesList =
     bencode2::decode(peersString);
 
   // ANNOUNCE_LIST
@@ -111,7 +111,7 @@ void AnnounceListTest::testSingleElementList() {
 
 void AnnounceListTest::testMultiElementList() {
   std::string peersString = "ll8:tracker18:tracker28:tracker3ee";
-  SharedHandle<ValueBase> announcesList = bencode2::decode(peersString);
+  std::shared_ptr<ValueBase> announcesList = bencode2::decode(peersString);
 
   // ANNOUNCE_LIST
   // [ [ tracker1, tracker2, tracker3 ] ]
@@ -144,7 +144,7 @@ void AnnounceListTest::testMultiElementList() {
 
 void AnnounceListTest::testSingleAndMulti() {
   std::string peersString = "ll8:tracker18:tracker2el8:tracker3ee";
-  SharedHandle<ValueBase> announcesList = bencode2::decode(peersString);
+  std::shared_ptr<ValueBase> announcesList = bencode2::decode(peersString);
 
   // ANNOUNCE_LIST
   // [ [ tracker1, tracker2 ], [ tracker3 ] ]
@@ -170,14 +170,14 @@ void AnnounceListTest::testSingleAndMulti() {
 
 void AnnounceListTest::testNoGroup() {
   std::string peersString = "llee";
-  SharedHandle<ValueBase> announcesList = bencode2::decode(peersString);
+  std::shared_ptr<ValueBase> announcesList = bencode2::decode(peersString);
   AnnounceList announceList(toVector(downcast<List>(announcesList)));
   CPPUNIT_ASSERT(announceList.countTier() == 0);
 }
 
 void AnnounceListTest::testNextEventIfAfterStarted() {
   std::string peersString = "ll8:tracker1ee";
-  SharedHandle<ValueBase> announcesList = bencode2::decode(peersString);
+  std::shared_ptr<ValueBase> announcesList = bencode2::decode(peersString);
 
   // ANNOUNCE_LIST
   // [ [ tracker1 ] ]
@@ -199,7 +199,7 @@ void AnnounceListTest::testNextEventIfAfterStarted() {
 
 void AnnounceListTest::testEvent() {
   std::string peersString = "ll8:tracker1el8:tracker2el8:tracker3ee";
-  SharedHandle<ValueBase> announcesList = bencode2::decode(peersString);
+  std::shared_ptr<ValueBase> announcesList = bencode2::decode(peersString);
 
   // ANNOUNCE_LIST
   // [ [ tracker1 ], [ tracker2 ], [ tracker3 ] ]
@@ -226,7 +226,7 @@ void AnnounceListTest::testEvent() {
 
 void AnnounceListTest::testCountStoppedAllowedTier() {
   std::string peersString = "ll8:tracker1el8:tracker2el8:tracker3ee";
-  SharedHandle<ValueBase> announcesList = bencode2::decode(peersString);
+  std::shared_ptr<ValueBase> announcesList = bencode2::decode(peersString);
 
   // ANNOUNCE_LIST
   // [ [ tracker1 ], [ tracker2 ], [ tracker3 ] ]
@@ -253,7 +253,7 @@ void AnnounceListTest::testCountStoppedAllowedTier() {
 
 void AnnounceListTest::testCountCompletedAllowedTier() {
   std::string peersString = "ll8:tracker1el8:tracker2el8:tracker3ee";
-  SharedHandle<ValueBase> announcesList = bencode2::decode(peersString);
+  std::shared_ptr<ValueBase> announcesList = bencode2::decode(peersString);
 
   // ANNOUNCE_LIST
   // [ [ tracker1 ], [ tracker2 ], [ tracker3 ] ]
@@ -285,12 +285,12 @@ std::deque<std::string> createUrls(const std::string& url) {
 }
 
 void AnnounceListTest::testMoveToStoppedAllowedTier() {
-  SharedHandle<AnnounceTier> t1(new AnnounceTier(createUrls("tracker1")));
-  SharedHandle<AnnounceTier> t2(new AnnounceTier(createUrls("tracker2")));
+  std::shared_ptr<AnnounceTier> t1(new AnnounceTier(createUrls("tracker1")));
+  std::shared_ptr<AnnounceTier> t2(new AnnounceTier(createUrls("tracker2")));
   t2->event = AnnounceTier::COMPLETED;
-  SharedHandle<AnnounceTier> t3(new AnnounceTier(createUrls("tracker3")));
+  std::shared_ptr<AnnounceTier> t3(new AnnounceTier(createUrls("tracker3")));
 
-  std::deque<SharedHandle<AnnounceTier> > tiers;
+  std::deque<std::shared_ptr<AnnounceTier> > tiers;
   tiers.push_back(t1);
   tiers.push_back(t2);
   tiers.push_back(t3);
@@ -311,12 +311,12 @@ void AnnounceListTest::testMoveToStoppedAllowedTier() {
 }
 
 void AnnounceListTest::testMoveToCompletedAllowedTier() {
-  SharedHandle<AnnounceTier> t1(new AnnounceTier(createUrls("tracker1")));
-  SharedHandle<AnnounceTier> t2(new AnnounceTier(createUrls("tracker2")));
+  std::shared_ptr<AnnounceTier> t1(new AnnounceTier(createUrls("tracker1")));
+  std::shared_ptr<AnnounceTier> t2(new AnnounceTier(createUrls("tracker2")));
   t2->event = AnnounceTier::COMPLETED;
-  SharedHandle<AnnounceTier> t3(new AnnounceTier(createUrls("tracker3")));
+  std::shared_ptr<AnnounceTier> t3(new AnnounceTier(createUrls("tracker3")));
 
-  std::deque<SharedHandle<AnnounceTier> > tiers;
+  std::deque<std::shared_ptr<AnnounceTier> > tiers;
   tiers.push_back(t1);
   tiers.push_back(t2);
   tiers.push_back(t3);
diff --git a/test/Aria2ApiTest.cc b/test/Aria2ApiTest.cc
index 897893ba..e84482d5 100644
--- a/test/Aria2ApiTest.cc
+++ b/test/Aria2ApiTest.cc
@@ -229,13 +229,13 @@ void Aria2ApiTest::testChangeGlobalOption()
 
 void Aria2ApiTest::testDownloadResultDH()
 {
-  SharedHandle<DownloadResult> dr1 =
+  std::shared_ptr<DownloadResult> dr1 =
     createDownloadResult(error_code::TIME_OUT, "http://example.org/timeout");
   dr1->option->put(PREF_DIR, "mydownload");
-  SharedHandle<DownloadResult> dr2 =
+  std::shared_ptr<DownloadResult> dr2 =
     createDownloadResult(error_code::NETWORK_PROBLEM,
                          "http://example.org/network");
-  SharedHandle<RequestGroupMan> gman =
+  std::shared_ptr<RequestGroupMan> gman =
     session_->context->reqinfo->getDownloadEngine()->getRequestGroupMan();
   gman->addDownloadResult(dr1);
   gman->addDownloadResult(dr2);
diff --git a/test/AuthConfigFactoryTest.cc b/test/AuthConfigFactoryTest.cc
index 5f534bfc..557bd51f 100644
--- a/test/AuthConfigFactoryTest.cc
+++ b/test/AuthConfigFactoryTest.cc
@@ -31,7 +31,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( AuthConfigFactoryTest );
 
 void AuthConfigFactoryTest::testCreateAuthConfig_http()
 {
-  SharedHandle<Request> req(new Request());
+  std::shared_ptr<Request> req(new Request());
   req->setUri("http://localhost/download/aria2-1.0.0.tar.bz2");
 
   Option option;
@@ -44,14 +44,14 @@ void AuthConfigFactoryTest::testCreateAuthConfig_http()
   CPPUNIT_ASSERT(!factory.createAuthConfig(req, &option));
 
   // with Netrc
-  SharedHandle<Netrc> netrc(new Netrc());
+  std::shared_ptr<Netrc> netrc(new Netrc());
   netrc->addAuthenticator
-    (SharedHandle<Authenticator>(new Authenticator("localhost",
+    (std::shared_ptr<Authenticator>(new Authenticator("localhost",
                                                    "localhostuser",
                                                    "localhostpass",
                                                    "localhostacct")));
   netrc->addAuthenticator
-    (SharedHandle<Authenticator>(new DefaultAuthenticator("default", "defaultpassword", "defaultaccount")));
+    (std::shared_ptr<Authenticator>(new DefaultAuthenticator("default", "defaultpassword", "defaultaccount")));
   factory.setNetrc(netrc);
 
   // not activated
@@ -88,7 +88,7 @@ void AuthConfigFactoryTest::testCreateAuthConfig_http()
 
 void AuthConfigFactoryTest::testCreateAuthConfig_httpNoChallenge()
 {
-  SharedHandle<Request> req(new Request());
+  std::shared_ptr<Request> req(new Request());
   req->setUri("http://localhost/download/aria2-1.0.0.tar.bz2");
 
   Option option;
@@ -100,14 +100,14 @@ void AuthConfigFactoryTest::testCreateAuthConfig_httpNoChallenge()
   CPPUNIT_ASSERT(!factory.createAuthConfig(req, &option));
 
   // with Netrc
-  SharedHandle<Netrc> netrc(new Netrc());
+  std::shared_ptr<Netrc> netrc(new Netrc());
   netrc->addAuthenticator
-    (SharedHandle<Authenticator>(new Authenticator("localhost",
+    (std::shared_ptr<Authenticator>(new Authenticator("localhost",
                                                    "localhostuser",
                                                    "localhostpass",
                                                    "localhostacct")));
   netrc->addAuthenticator
-    (SharedHandle<Authenticator>(new DefaultAuthenticator("default", "defaultpassword", "defaultaccount")));
+    (std::shared_ptr<Authenticator>(new DefaultAuthenticator("default", "defaultpassword", "defaultaccount")));
   factory.setNetrc(netrc);
 
   // not activated
@@ -134,7 +134,7 @@ void AuthConfigFactoryTest::testCreateAuthConfig_httpNoChallenge()
 
 void AuthConfigFactoryTest::testCreateAuthConfig_ftp()
 {
-  SharedHandle<Request> req(new Request());
+  std::shared_ptr<Request> req(new Request());
   req->setUri("ftp://localhost/download/aria2-1.0.0.tar.bz2");
 
   Option option;
@@ -147,9 +147,9 @@ void AuthConfigFactoryTest::testCreateAuthConfig_ftp()
                        factory.createAuthConfig(req, &option)->getAuthText());
 
   // with Netrc
-  SharedHandle<Netrc> netrc(new Netrc());
+  std::shared_ptr<Netrc> netrc(new Netrc());
   netrc->addAuthenticator
-    (SharedHandle<Authenticator>(new DefaultAuthenticator("default", "defaultpassword", "defaultaccount")));
+    (std::shared_ptr<Authenticator>(new DefaultAuthenticator("default", "defaultpassword", "defaultaccount")));
   factory.setNetrc(netrc);
   CPPUNIT_ASSERT_EQUAL(std::string("default:defaultpassword"),
                        factory.createAuthConfig(req, &option)->getAuthText());
@@ -180,7 +180,7 @@ void AuthConfigFactoryTest::testCreateAuthConfig_ftp()
   // Recreate netrc with entry for user aria2user
   netrc.reset(new Netrc());
   netrc->addAuthenticator
-    (SharedHandle<Authenticator>(new Authenticator("localhost",
+    (std::shared_ptr<Authenticator>(new Authenticator("localhost",
                                                    "aria2user",
                                                    "netrcpass",
                                                    "netrcacct")));
@@ -196,14 +196,14 @@ void AuthConfigFactoryTest::testCreateAuthConfig_ftp()
 }
 
 namespace {
-SharedHandle<AuthConfigFactory::BasicCred>
+std::shared_ptr<AuthConfigFactory::BasicCred>
 createBasicCred(const std::string& user,
                 const std::string& password,
                 const std::string& host, uint16_t port,
                 const std::string& path,
                 bool activated = false)
 {
-  SharedHandle<AuthConfigFactory::BasicCred> bc
+  std::shared_ptr<AuthConfigFactory::BasicCred> bc
     (new AuthConfigFactory::BasicCred(user, password, host, port, path,
                                       activated));
   return bc;
@@ -229,7 +229,7 @@ void AuthConfigFactoryTest::testUpdateBasicCred()
   factory.updateBasicCred
     (createBasicCred("jack", "jackx", "mirror", 80, "/doc", true));
 
-  SharedHandle<Request> req(new Request());
+  std::shared_ptr<Request> req(new Request());
   req->setUri("http://localhost/download/v2.6/Changelog");
   CPPUNIT_ASSERT_EQUAL(std::string("price:j38jdc"),
                        factory.createAuthConfig(req, &option)->getAuthText());
diff --git a/test/Bencode2Test.cc b/test/Bencode2Test.cc
index 5916bd76..e412110e 100644
--- a/test/Bencode2Test.cc
+++ b/test/Bencode2Test.cc
@@ -25,10 +25,10 @@ void Bencode2Test::testEncode()
     Dict dict;
     dict["name"] = String::g("aria2");
     dict["loc"] = Integer::g(80000);
-    SharedHandle<List> files = List::g();
+    std::shared_ptr<List> files = List::g();
     files->append(String::g("aria2c"));
     dict["files"] = files;
-    SharedHandle<Dict> attrs = Dict::g();
+    std::shared_ptr<Dict> attrs = Dict::g();
     attrs->put("license", String::g("GPL"));
     dict["attrs"] = attrs;
 
diff --git a/test/BittorrentHelperTest.cc b/test/BittorrentHelperTest.cc
index fe4714e9..23c6b5b9 100644
--- a/test/BittorrentHelperTest.cc
+++ b/test/BittorrentHelperTest.cc
@@ -75,7 +75,7 @@ class BittorrentHelperTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testAdjustAnnounceUri);
   CPPUNIT_TEST_SUITE_END();
 public:
-  SharedHandle<Option> option_;
+  std::shared_ptr<Option> option_;
 
   void setUp()
   {
@@ -136,7 +136,7 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION(BittorrentHelperTest);
 
 void BittorrentHelperTest::testGetInfoHash() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
 
   std::string correctHash = "248d0a1cd08284299de78d5c1ed359bb46717d8c";
@@ -145,7 +145,7 @@ void BittorrentHelperTest::testGetInfoHash() {
 }
 
 void BittorrentHelperTest::testGetPieceHash() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
 
   CPPUNIT_ASSERT_EQUAL(std::string("AAAAAAAAAAAAAAAAAAAA"),
@@ -161,39 +161,39 @@ void BittorrentHelperTest::testGetPieceHash() {
 }
 
 void BittorrentHelperTest::testGetFileEntries() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   option_->put(PREF_MAX_CONNECTION_PER_SERVER, "10");
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
   // This is multi-file torrent.
-  std::vector<SharedHandle<FileEntry> > fileEntries = dctx->getFileEntries();
+  std::vector<std::shared_ptr<FileEntry> > fileEntries = dctx->getFileEntries();
   // There are 2 file entries.
   CPPUNIT_ASSERT_EQUAL((size_t)2, fileEntries.size());
-  std::vector<SharedHandle<FileEntry> >::iterator itr = fileEntries.begin();
+  std::vector<std::shared_ptr<FileEntry> >::iterator itr = fileEntries.begin();
 
-  SharedHandle<FileEntry> fileEntry1 = *itr;
+  std::shared_ptr<FileEntry> fileEntry1 = *itr;
   CPPUNIT_ASSERT_EQUAL(std::string("./aria2-test/aria2/src/aria2c"),
                        fileEntry1->getPath());
   CPPUNIT_ASSERT_EQUAL(std::string("aria2-test/aria2/src/aria2c"),
                        fileEntry1->getOriginalName());
   CPPUNIT_ASSERT_EQUAL(10, fileEntry1->getMaxConnectionPerServer());
   itr++;
-  SharedHandle<FileEntry> fileEntry2 = *itr;
+  std::shared_ptr<FileEntry> fileEntry2 = *itr;
   CPPUNIT_ASSERT_EQUAL(std::string("./aria2-test/aria2-0.2.2.tar.bz2"),
                        fileEntry2->getPath());
   CPPUNIT_ASSERT_EQUAL(10, fileEntry2->getMaxConnectionPerServer());
 }
 
 void BittorrentHelperTest::testGetFileEntriesSingle() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   option_->put(PREF_MAX_CONNECTION_PER_SERVER, "10");
   load(A2_TEST_DIR"/single.torrent", dctx, option_);
   // This is multi-file torrent.
-  std::vector<SharedHandle<FileEntry> > fileEntries = dctx->getFileEntries();
+  std::vector<std::shared_ptr<FileEntry> > fileEntries = dctx->getFileEntries();
   // There is 1 file entry.
   CPPUNIT_ASSERT_EQUAL((size_t)1, fileEntries.size());
-  std::vector<SharedHandle<FileEntry> >::iterator itr = fileEntries.begin();
+  std::vector<std::shared_ptr<FileEntry> >::iterator itr = fileEntries.begin();
 
-  SharedHandle<FileEntry> fileEntry1 = *itr;
+  std::shared_ptr<FileEntry> fileEntry1 = *itr;
   CPPUNIT_ASSERT_EQUAL(std::string("./aria2-0.8.2.tar.bz2"),
                        fileEntry1->getPath());
   CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.8.2.tar.bz2"),
@@ -202,42 +202,42 @@ void BittorrentHelperTest::testGetFileEntriesSingle() {
 }
 
 void BittorrentHelperTest::testGetTotalLength() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
 
   CPPUNIT_ASSERT_EQUAL((int64_t)384LL, dctx->getTotalLength());
 }
 
 void BittorrentHelperTest::testGetTotalLengthSingle() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/single.torrent", dctx, option_);
 
   CPPUNIT_ASSERT_EQUAL((int64_t)384LL, dctx->getTotalLength());
 }
 
 void BittorrentHelperTest::testGetFileModeMulti() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
 
   CPPUNIT_ASSERT_EQUAL(BT_FILE_MODE_MULTI, getTorrentAttrs(dctx)->mode);
 }
 
 void BittorrentHelperTest::testGetFileModeSingle() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/single.torrent", dctx, option_);
 
   CPPUNIT_ASSERT_EQUAL(BT_FILE_MODE_SINGLE, getTorrentAttrs(dctx)->mode);
 }
 
 void BittorrentHelperTest::testGetNameMulti() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
 
   CPPUNIT_ASSERT_EQUAL(std::string("aria2-test"), getTorrentAttrs(dctx)->name);
 }
 
 void BittorrentHelperTest::testGetNameSingle() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/single.torrent", dctx, option_);
 
   CPPUNIT_ASSERT_EQUAL(std::string("./aria2-0.8.2.tar.bz2"),
@@ -248,7 +248,7 @@ void BittorrentHelperTest::testGetNameSingle() {
 
 void BittorrentHelperTest::testOverrideName()
 {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_, "aria2-override.name");
   CPPUNIT_ASSERT_EQUAL(std::string("./aria2-override.name"),
                        dctx->getBasePath());
@@ -258,9 +258,9 @@ void BittorrentHelperTest::testOverrideName()
 
 
 void BittorrentHelperTest::testGetAnnounceTier() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/single.torrent", dctx, option_);
-  SharedHandle<TorrentAttribute> attrs = getTorrentAttrs(dctx);
+  std::shared_ptr<TorrentAttribute> attrs = getTorrentAttrs(dctx);
   // There is 1 tier.
   CPPUNIT_ASSERT_EQUAL((size_t)1, attrs->announceList.size());
 
@@ -270,9 +270,9 @@ void BittorrentHelperTest::testGetAnnounceTier() {
 }
 
 void BittorrentHelperTest::testGetAnnounceTierAnnounceList() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
-  SharedHandle<TorrentAttribute> attrs = getTorrentAttrs(dctx);
+  std::shared_ptr<TorrentAttribute> attrs = getTorrentAttrs(dctx);
   // There are 3 tiers.
   CPPUNIT_ASSERT_EQUAL((size_t)3, attrs->announceList.size());
 
@@ -290,14 +290,14 @@ void BittorrentHelperTest::testGetAnnounceTierAnnounceList() {
 }
 
 void BittorrentHelperTest::testGetPieceLength() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
 
   CPPUNIT_ASSERT_EQUAL(128, dctx->getPieceLength());
 }
 
 void BittorrentHelperTest::testGetInfoHashAsString() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
 
   CPPUNIT_ASSERT_EQUAL(std::string("248d0a1cd08284299de78d5c1ed359bb46717d8c"),
@@ -345,17 +345,17 @@ void BittorrentHelperTest::testComputeFastSet()
 }
 
 void BittorrentHelperTest::testGetFileEntries_multiFileUrlList() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/url-list-multiFile.torrent", dctx, option_);
   // This is multi-file torrent.
-  const std::vector<SharedHandle<FileEntry> >& fileEntries =
+  const std::vector<std::shared_ptr<FileEntry> >& fileEntries =
     dctx->getFileEntries();
   // There are 2 file entries.
   CPPUNIT_ASSERT_EQUAL((size_t)2, fileEntries.size());
-  std::vector<SharedHandle<FileEntry> >::const_iterator itr =
+  std::vector<std::shared_ptr<FileEntry> >::const_iterator itr =
     fileEntries.begin();
 
-  const SharedHandle<FileEntry>& fileEntry1 = *itr;
+  const std::shared_ptr<FileEntry>& fileEntry1 = *itr;
   CPPUNIT_ASSERT_EQUAL(std::string("./aria2-test@/aria2@/src@/aria2c@"),
                        fileEntry1->getPath());
   const std::deque<std::string>& uris1 = fileEntry1->getRemainingUris();
@@ -366,7 +366,7 @@ void BittorrentHelperTest::testGetFileEntries_multiFileUrlList() {
                        uris1[1]);
 
   ++itr;
-  const SharedHandle<FileEntry>& fileEntry2 = *itr;
+  const std::shared_ptr<FileEntry>& fileEntry2 = *itr;
   CPPUNIT_ASSERT_EQUAL(std::string("./aria2-test@/aria2-0.2.2.tar.bz2"),
                        fileEntry2->getPath());
   const std::deque<std::string>& uris2 = fileEntry2->getRemainingUris();
@@ -378,15 +378,15 @@ void BittorrentHelperTest::testGetFileEntries_multiFileUrlList() {
 }
 
 void BittorrentHelperTest::testGetFileEntries_singleFileUrlList() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/url-list-singleFile.torrent", dctx, option_);
   // This is single-file torrent.
-  const std::vector<SharedHandle<FileEntry> >& fileEntries =
+  const std::vector<std::shared_ptr<FileEntry> >& fileEntries =
     dctx->getFileEntries();
   // There are 1 file entries.
   CPPUNIT_ASSERT_EQUAL((size_t)1, fileEntries.size());
 
-  const SharedHandle<FileEntry>& fileEntry1 = fileEntries.front();
+  const std::shared_ptr<FileEntry>& fileEntry1 = fileEntries.front();
   CPPUNIT_ASSERT_EQUAL(std::string("./aria2.tar.bz2"),
                        fileEntry1->getPath());
   const std::deque<std::string>& uris1 = fileEntry1->getRemainingUris();
@@ -396,15 +396,15 @@ void BittorrentHelperTest::testGetFileEntries_singleFileUrlList() {
 }
 
 void BittorrentHelperTest::testGetFileEntries_singleFileUrlListEndsWithSlash() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/url-list-singleFileEndsWithSlash.torrent", dctx, option_);
   // This is single-file torrent.
-  const std::vector<SharedHandle<FileEntry> >& fileEntries =
+  const std::vector<std::shared_ptr<FileEntry> >& fileEntries =
     dctx->getFileEntries();
   // There are 1 file entries.
   CPPUNIT_ASSERT_EQUAL((size_t)1, fileEntries.size());
 
-  const SharedHandle<FileEntry>& fileEntry1 = fileEntries.front();
+  const std::shared_ptr<FileEntry>& fileEntry1 = fileEntries.front();
   CPPUNIT_ASSERT_EQUAL(std::string("./aria2@.tar.bz2"),
                        fileEntry1->getPath());
   const std::deque<std::string>& uris1 = fileEntry1->getRemainingUris();
@@ -415,25 +415,25 @@ void BittorrentHelperTest::testGetFileEntries_singleFileUrlListEndsWithSlash() {
 
 void BittorrentHelperTest::testLoadFromMemory_multiFileNonUtf8Path()
 {
-  SharedHandle<List> path = List::g();
+  std::shared_ptr<List> path = List::g();
   path->append("path");
   path->append(fromHex("90a28a")+"E");
-  SharedHandle<Dict> file = Dict::g();
+  std::shared_ptr<Dict> file = Dict::g();
   file->put("length", Integer::g(1024));
   file->put("path", path);
-  SharedHandle<List> files = List::g();
+  std::shared_ptr<List> files = List::g();
   files->append(file);
-  SharedHandle<Dict> info = Dict::g();
+  std::shared_ptr<Dict> info = Dict::g();
   info->put("files", files);
   info->put("piece length", Integer::g(1024));
   info->put("pieces", "01234567890123456789");
   info->put("name", fromHex("1b")+"$B%O%m!<"+fromHex("1b")+"(B");
   Dict dict;
   dict.put("info", info);
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   loadFromMemory(bencode2::encode(&dict), dctx, option_, "default");
 
-  const SharedHandle<FileEntry>& fe = dctx->getFirstFileEntry();
+  const std::shared_ptr<FileEntry>& fe = dctx->getFirstFileEntry();
   CPPUNIT_ASSERT_EQUAL
     (std::string("./%1B%24B%25O%25m%21%3C%1B%28B/path/%90%A2%8AE"),
      fe->getPath());
@@ -443,17 +443,17 @@ void BittorrentHelperTest::testLoadFromMemory_multiFileNonUtf8Path()
 
 void BittorrentHelperTest::testLoadFromMemory_singleFileNonUtf8Path()
 {
-  SharedHandle<Dict> info = Dict::g();
+  std::shared_ptr<Dict> info = Dict::g();
   info->put("piece length", Integer::g(1024));
   info->put("pieces", "01234567890123456789");
   info->put("name", fromHex("90a28a")+"E");
   info->put("length", Integer::g(1024));
   Dict dict;
   dict.put("info", info);
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   loadFromMemory(bencode2::encode(&dict), dctx, option_, "default");
 
-  const SharedHandle<FileEntry>& fe = dctx->getFirstFileEntry();
+  const std::shared_ptr<FileEntry>& fe = dctx->getFirstFileEntry();
   CPPUNIT_ASSERT_EQUAL(std::string("./%90%A2%8AE"), fe->getPath());
 }
 
@@ -461,7 +461,7 @@ void BittorrentHelperTest::testLoadFromMemory()
 {
   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";
 
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   loadFromMemory(memory, dctx, option_, "default");
 
   std::string correctHash = "248d0a1cd08284299de78d5c1ed359bb46717d8c";
@@ -474,7 +474,7 @@ void BittorrentHelperTest::testLoadFromMemory_somethingMissing()
   // pieces missing
   try {
     std::string memory = "d8:announce36:http://aria.rednoah.com/announce.php4:infod4:name13:aria2.tar.bz26:lengthi262144eee";
-    SharedHandle<DownloadContext> dctx(new DownloadContext());
+    std::shared_ptr<DownloadContext> dctx(new DownloadContext());
     loadFromMemory(memory, dctx, option_, "default");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception& e) {
@@ -486,7 +486,7 @@ void BittorrentHelperTest::testLoadFromMemory_overrideName()
 {
   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";
 
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   loadFromMemory(memory, dctx, option_, "default", "aria2-override.name");
 
   CPPUNIT_ASSERT_EQUAL(std::string("aria2-override.name"),
@@ -498,7 +498,7 @@ void BittorrentHelperTest::testLoadFromMemory_multiFileDirTraversal()
   std::string memory =
     "d8:announce27:http://example.com/announce4:infod5:filesld6:lengthi262144e4:pathl7:../dir14:dir28:file.imgeee4:name14:../name1/name212:piece lengthi262144e6:pieces20:00000000000000000000ee";
 
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   try {
     loadFromMemory(memory, dctx, option_, "default");
     CPPUNIT_FAIL("Exception must be thrown.");
@@ -512,7 +512,7 @@ void BittorrentHelperTest::testLoadFromMemory_singleFileDirTraversal()
   std::string memory =
     "d8:announce27:http://example.com/announce4:infod4:name14:../name1/name26:lengthi262144e12:piece lengthi262144e6:pieces20:00000000000000000000ee";
 
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   try {
     loadFromMemory(memory, dctx, option_, "default");
   } catch(RecoverableException& e) {
@@ -531,10 +531,10 @@ void BittorrentHelperTest::testGetNodes()
       "12:piece lengthi262144e"
       "6:pieces20:AAAAAAAAAAAAAAAAAAAA"
       "ee";
-    SharedHandle<DownloadContext> dctx(new DownloadContext());
+    std::shared_ptr<DownloadContext> dctx(new DownloadContext());
     loadFromMemory(memory, dctx, option_, "default");
 
-    SharedHandle<TorrentAttribute> attrs = getTorrentAttrs(dctx);
+    std::shared_ptr<TorrentAttribute> attrs = getTorrentAttrs(dctx);
     CPPUNIT_ASSERT_EQUAL((size_t)2, attrs->nodes.size());
     CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), attrs->nodes[0].first);
     CPPUNIT_ASSERT_EQUAL((uint16_t)6881, attrs->nodes[0].second);
@@ -551,10 +551,10 @@ void BittorrentHelperTest::testGetNodes()
       "12:piece lengthi262144e"
       "6:pieces20:AAAAAAAAAAAAAAAAAAAA"
       "ee";
-    SharedHandle<DownloadContext> dctx(new DownloadContext());
+    std::shared_ptr<DownloadContext> dctx(new DownloadContext());
     loadFromMemory(memory, dctx, option_, "default");
 
-    SharedHandle<TorrentAttribute> attrs = getTorrentAttrs(dctx);
+    std::shared_ptr<TorrentAttribute> attrs = getTorrentAttrs(dctx);
     CPPUNIT_ASSERT_EQUAL((size_t)1, attrs->nodes.size());
     CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.2"), attrs->nodes[0].first);
     CPPUNIT_ASSERT_EQUAL((uint16_t)6882, attrs->nodes[0].second);
@@ -569,10 +569,10 @@ void BittorrentHelperTest::testGetNodes()
       "12:piece lengthi262144e"
       "6:pieces20:AAAAAAAAAAAAAAAAAAAA"
       "ee";
-    SharedHandle<DownloadContext> dctx(new DownloadContext());
+    std::shared_ptr<DownloadContext> dctx(new DownloadContext());
     loadFromMemory(memory, dctx, option_, "default");
 
-    SharedHandle<TorrentAttribute> attrs = getTorrentAttrs(dctx);
+    std::shared_ptr<TorrentAttribute> attrs = getTorrentAttrs(dctx);
     CPPUNIT_ASSERT_EQUAL((size_t)1, attrs->nodes.size());
     CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.2"), attrs->nodes[0].first);
     CPPUNIT_ASSERT_EQUAL((uint16_t)6882, attrs->nodes[0].second);
@@ -587,10 +587,10 @@ void BittorrentHelperTest::testGetNodes()
       "12:piece lengthi262144e"
       "6:pieces20:AAAAAAAAAAAAAAAAAAAA"
       "ee";
-    SharedHandle<DownloadContext> dctx(new DownloadContext());
+    std::shared_ptr<DownloadContext> dctx(new DownloadContext());
     loadFromMemory(memory, dctx, option_, "default");
 
-    SharedHandle<TorrentAttribute> attrs = getTorrentAttrs(dctx);
+    std::shared_ptr<TorrentAttribute> attrs = getTorrentAttrs(dctx);
     CPPUNIT_ASSERT_EQUAL((size_t)1, attrs->nodes.size());
     CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.2"), attrs->nodes[0].first);
     CPPUNIT_ASSERT_EQUAL((uint16_t)6882, attrs->nodes[0].second);
@@ -604,10 +604,10 @@ void BittorrentHelperTest::testGetNodes()
       "12:piece lengthi262144e"
       "6:pieces20:AAAAAAAAAAAAAAAAAAAA"
       "ee";
-    SharedHandle<DownloadContext> dctx(new DownloadContext());
+    std::shared_ptr<DownloadContext> dctx(new DownloadContext());
     loadFromMemory(memory, dctx, option_, "default");
 
-    SharedHandle<TorrentAttribute> attrs = getTorrentAttrs(dctx);
+    std::shared_ptr<TorrentAttribute> attrs = getTorrentAttrs(dctx);
     CPPUNIT_ASSERT_EQUAL((size_t)0, attrs->nodes.size());
   }
   {
@@ -620,10 +620,10 @@ void BittorrentHelperTest::testGetNodes()
       "12:piece lengthi262144e"
       "6:pieces20:AAAAAAAAAAAAAAAAAAAA"
       "ee";
-    SharedHandle<DownloadContext> dctx(new DownloadContext());
+    std::shared_ptr<DownloadContext> dctx(new DownloadContext());
     loadFromMemory(memory, dctx, option_, "default");
 
-    SharedHandle<TorrentAttribute> attrs = getTorrentAttrs(dctx);
+    std::shared_ptr<TorrentAttribute> attrs = getTorrentAttrs(dctx);
     CPPUNIT_ASSERT_EQUAL((size_t)1, attrs->nodes.size());
     CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.2"), attrs->nodes[0].first);
     CPPUNIT_ASSERT_EQUAL((uint16_t)6882, attrs->nodes[0].second);
@@ -632,13 +632,13 @@ void BittorrentHelperTest::testGetNodes()
 
 void BittorrentHelperTest::testGetBasePath()
 {
-  SharedHandle<DownloadContext> singleCtx(new DownloadContext());
+  std::shared_ptr<DownloadContext> singleCtx(new DownloadContext());
   load(A2_TEST_DIR"/single.torrent", singleCtx, option_);
   singleCtx->setFilePathWithIndex(1, "new-path");
   CPPUNIT_ASSERT_EQUAL(std::string("new-path"), singleCtx->getBasePath());
 
   option_->put(PREF_DIR, "downloads");
-  SharedHandle<DownloadContext> multiCtx(new DownloadContext());
+  std::shared_ptr<DownloadContext> multiCtx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", multiCtx, option_);
   CPPUNIT_ASSERT_EQUAL(std::string("downloads/aria2-test"),
                        multiCtx->getBasePath());
@@ -646,7 +646,7 @@ void BittorrentHelperTest::testGetBasePath()
 
 void BittorrentHelperTest::testSetFileFilter_single()
 {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/single.torrent", dctx, option_);
 
   CPPUNIT_ASSERT(dctx->getFirstFileEntry()->isRequested());
@@ -669,7 +669,7 @@ void BittorrentHelperTest::testSetFileFilter_single()
 
 void BittorrentHelperTest::testSetFileFilter_multi()
 {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
 
   CPPUNIT_ASSERT(dctx->getFileEntries()[0]->isRequested());
@@ -700,7 +700,7 @@ void BittorrentHelperTest::testSetFileFilter_multi()
 
 void BittorrentHelperTest::testUTF8Torrent()
 {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/utf8.torrent", dctx, option_);
   CPPUNIT_ASSERT_EQUAL(std::string("name in utf-8"),
                        getTorrentAttrs(dctx)->name);
@@ -712,7 +712,7 @@ void BittorrentHelperTest::testUTF8Torrent()
 
 void BittorrentHelperTest::testEtc()
 {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
   CPPUNIT_ASSERT_EQUAL(std::string("REDNOAH.COM RULES"),
                        getTorrentAttrs(dctx)->comment);
@@ -743,13 +743,13 @@ void BittorrentHelperTest::testCheckBitfield()
 }
 
 void BittorrentHelperTest::testMetadata() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
   std::string torrentData = readFile(A2_TEST_DIR"/test.torrent");
-  SharedHandle<ValueBase> tr = bencode2::decode(torrentData);
-  SharedHandle<ValueBase> infoDic = downcast<Dict>(tr)->get("info");
+  std::shared_ptr<ValueBase> tr = bencode2::decode(torrentData);
+  std::shared_ptr<ValueBase> infoDic = downcast<Dict>(tr)->get("info");
   std::string metadata = bencode2::encode(infoDic);
-  SharedHandle<TorrentAttribute> attrs = getTorrentAttrs(dctx);
+  std::shared_ptr<TorrentAttribute> attrs = getTorrentAttrs(dctx);
   CPPUNIT_ASSERT(metadata == attrs->metadata);
   CPPUNIT_ASSERT_EQUAL(metadata.size(), attrs->metadataSize);
 }
@@ -759,7 +759,7 @@ void BittorrentHelperTest::testParseMagnet()
   std::string magnet =
     "magnet:?xt=urn:btih:248d0a1cd08284299de78d5c1ed359bb46717d8c&dn=aria2"
     "&tr=http://tracker1&tr=http://tracker2";
-  SharedHandle<TorrentAttribute> attrs = bittorrent::parseMagnet(magnet);
+  std::shared_ptr<TorrentAttribute> attrs = bittorrent::parseMagnet(magnet);
   CPPUNIT_ASSERT_EQUAL(std::string("248d0a1cd08284299de78d5c1ed359bb46717d8c"),
                        util::toHex(attrs->infoHash));
   CPPUNIT_ASSERT_EQUAL(std::string("[METADATA]aria2"), attrs->name);
@@ -788,7 +788,7 @@ void BittorrentHelperTest::testParseMagnet_base32()
   std::string infoHash = "248d0a1cd08284299de78d5c1ed359bb46717d8c";
   std::string base32InfoHash = base32::encode(fromHex(infoHash));
   std::string magnet = "magnet:?xt=urn:btih:"+base32InfoHash+"&dn=aria2";
-  SharedHandle<TorrentAttribute> attrs = bittorrent::parseMagnet(magnet);
+  std::shared_ptr<TorrentAttribute> attrs = bittorrent::parseMagnet(magnet);
   CPPUNIT_ASSERT_EQUAL
     (std::string("248d0a1cd08284299de78d5c1ed359bb46717d8c"),
      util::toHex(attrs->infoHash));
@@ -797,7 +797,7 @@ void BittorrentHelperTest::testParseMagnet_base32()
 void BittorrentHelperTest::testMetadata2Torrent()
 {
   std::string metadata = "METADATA";
-  SharedHandle<TorrentAttribute> attrs(new TorrentAttribute());
+  std::shared_ptr<TorrentAttribute> attrs(new TorrentAttribute());
   CPPUNIT_ASSERT_EQUAL
     (std::string("d4:infoMETADATAe"), metadata2Torrent(metadata, attrs));
   attrs->announceList.push_back(std::vector<std::string>());
@@ -813,7 +813,7 @@ void BittorrentHelperTest::testMetadata2Torrent()
 
 void BittorrentHelperTest::testTorrent2Magnet()
 {
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
 
   CPPUNIT_ASSERT_EQUAL
@@ -830,8 +830,8 @@ void BittorrentHelperTest::testExtractPeerFromString()
   std::string hextext = "100210354527354678541237324732171ae1";
   hextext += "20010db8bd0501d2288a1fc0000110ee1ae2";
   std::string peersstr = "36:"+fromHex(hextext);
-  SharedHandle<ValueBase> str = bencode2::decode(peersstr);
-  std::deque<SharedHandle<Peer> > peers;
+  std::shared_ptr<ValueBase> str = bencode2::decode(peersstr);
+  std::deque<std::shared_ptr<Peer> > peers;
   extractPeer(str, AF_INET6, std::back_inserter(peers));
   CPPUNIT_ASSERT_EQUAL((size_t)2, peers.size());
   CPPUNIT_ASSERT_EQUAL(std::string("1002:1035:4527:3546:7854:1237:3247:3217"),
@@ -860,12 +860,12 @@ void BittorrentHelperTest::testExtractPeerFromList()
     "d5:peersld2:ip11:192.168.0.17:peer id20:aria2-00000000000000"
     "4:porti2006eeee";
 
-  SharedHandle<ValueBase> dict = bencode2::decode(peersString);
+  std::shared_ptr<ValueBase> dict = bencode2::decode(peersString);
 
-  std::deque<SharedHandle<Peer> > peers;
+  std::deque<std::shared_ptr<Peer> > peers;
   extractPeer(downcast<Dict>(dict)->get("peers"), AF_INET, std::back_inserter(peers));
   CPPUNIT_ASSERT_EQUAL((size_t)1, peers.size());
-  SharedHandle<Peer> peer = *peers.begin();
+  std::shared_ptr<Peer> peer = *peers.begin();
   CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), peer->getIPAddress());
   CPPUNIT_ASSERT_EQUAL((uint16_t)2006, peer->getPort());
 }
@@ -877,12 +877,12 @@ void BittorrentHelperTest::testExtract2PeersFromList()
     "4:porti65535eed2:ip11:192.168.0.27:peer id20:aria2-00000000000000"
     "4:porti2007eeee";
 
-  SharedHandle<ValueBase> dict = bencode2::decode(peersString);
+  std::shared_ptr<ValueBase> dict = bencode2::decode(peersString);
 
-  std::deque<SharedHandle<Peer> > peers;
+  std::deque<std::shared_ptr<Peer> > peers;
   extractPeer(downcast<Dict>(dict)->get("peers"), AF_INET, std::back_inserter(peers));
   CPPUNIT_ASSERT_EQUAL((size_t)2, peers.size());
-  SharedHandle<Peer> peer = *peers.begin();
+  std::shared_ptr<Peer> peer = *peers.begin();
   CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), peer->getIPAddress());
   CPPUNIT_ASSERT_EQUAL((uint16_t)65535, peer->getPort());
 
@@ -927,7 +927,7 @@ void BittorrentHelperTest::testUnpackcompact()
 
 void BittorrentHelperTest::testRemoveAnnounceUri()
 {
-  SharedHandle<TorrentAttribute> attrs(new TorrentAttribute());
+  std::shared_ptr<TorrentAttribute> attrs(new TorrentAttribute());
   std::vector<std::string> tier1;
   tier1.push_back("http://host1/announce");
   std::vector<std::string> tier2;
@@ -953,7 +953,7 @@ void BittorrentHelperTest::testRemoveAnnounceUri()
 
 void BittorrentHelperTest::testAddAnnounceUri()
 {
-  SharedHandle<TorrentAttribute> attrs(new TorrentAttribute());
+  std::shared_ptr<TorrentAttribute> attrs(new TorrentAttribute());
   std::vector<std::string> addUris;
   addUris.push_back("http://host1/announce");
   addUris.push_back("http://host2/announce");
@@ -971,7 +971,7 @@ void BittorrentHelperTest::testAddAnnounceUri()
 
 void BittorrentHelperTest::testAdjustAnnounceUri()
 {
-  SharedHandle<TorrentAttribute> attrs(new TorrentAttribute());
+  std::shared_ptr<TorrentAttribute> attrs(new TorrentAttribute());
   std::vector<std::string> tier1;
   tier1.push_back("http://host1/announce");
   std::vector<std::string> tier2;
@@ -980,7 +980,7 @@ void BittorrentHelperTest::testAdjustAnnounceUri()
   attrs->announceList.push_back(tier1);
   attrs->announceList.push_back(tier2);
 
-  SharedHandle<Option> option(new Option());
+  std::shared_ptr<Option> option(new Option());
   option->put(PREF_BT_TRACKER, "http://host1/announce,http://host4/announce");
   option->put(PREF_BT_EXCLUDE_TRACKER,
               "http://host1/announce,http://host2/announce");
diff --git a/test/BtAllowedFastMessageTest.cc b/test/BtAllowedFastMessageTest.cc
index e8d1fa4d..a1065997 100644
--- a/test/BtAllowedFastMessageTest.cc
+++ b/test/BtAllowedFastMessageTest.cc
@@ -39,7 +39,7 @@ void BtAllowedFastMessageTest::testCreate() {
   unsigned char msg[9];
   bittorrent::createPeerMessageString(msg, sizeof(msg), 5, 17);
   bittorrent::setIntParam(&msg[5], 12345);
-  SharedHandle<BtAllowedFastMessage> pm
+  std::shared_ptr<BtAllowedFastMessage> pm
     (BtAllowedFastMessage::create(&msg[4], 5));
   CPPUNIT_ASSERT_EQUAL((uint8_t)17, pm->getId());
   CPPUNIT_ASSERT_EQUAL((size_t)12345, pm->getIndex());
@@ -76,7 +76,7 @@ void BtAllowedFastMessageTest::testCreateMessage() {
 void BtAllowedFastMessageTest::testDoReceivedAction() {
   BtAllowedFastMessage msg;
   msg.setIndex(1);
-  SharedHandle<Peer> peer(new Peer("localhost", 6969));
+  std::shared_ptr<Peer> peer(new Peer("localhost", 6969));
   peer->allocateSessionResource(1024, 1024*1024);
   peer->setFastExtensionEnabled(true);
   msg.setPeer(peer);
@@ -94,12 +94,12 @@ void BtAllowedFastMessageTest::testDoReceivedAction() {
 void BtAllowedFastMessageTest::testOnSendComplete() {
   BtAllowedFastMessage msg;
   msg.setIndex(1);
-  SharedHandle<Peer> peer(new Peer("localhost", 6969));
+  std::shared_ptr<Peer> peer(new Peer("localhost", 6969));
   peer->allocateSessionResource(1024, 1024*1024);
   peer->setFastExtensionEnabled(true);
   msg.setPeer(peer);
   CPPUNIT_ASSERT(!peer->isInAmAllowedIndexSet(1));
-  SharedHandle<ProgressUpdate> pu(msg.getProgressUpdate());
+  std::shared_ptr<ProgressUpdate> pu(msg.getProgressUpdate());
   pu->update(0, true);
   CPPUNIT_ASSERT(peer->isInAmAllowedIndexSet(1));
 }
diff --git a/test/BtBitfieldMessageTest.cc b/test/BtBitfieldMessageTest.cc
index 826b219d..475c8a46 100644
--- a/test/BtBitfieldMessageTest.cc
+++ b/test/BtBitfieldMessageTest.cc
@@ -44,7 +44,7 @@ void BtBitfieldMessageTest::testCreate() {
   unsigned char bitfield[2];
   memset(bitfield, 0xff, sizeof(bitfield));
   memcpy(&msg[5], bitfield, sizeof(bitfield));
-  SharedHandle<BtBitfieldMessage> pm(BtBitfieldMessage::create(&msg[4], 3));
+  std::shared_ptr<BtBitfieldMessage> pm(BtBitfieldMessage::create(&msg[4], 3));
   CPPUNIT_ASSERT_EQUAL((uint8_t)5, pm->getId());
   CPPUNIT_ASSERT(memcmp(bitfield, pm->getBitfield(), sizeof(bitfield)) == 0);
   CPPUNIT_ASSERT_EQUAL((size_t)2, pm->getBitfieldLength());
@@ -81,11 +81,11 @@ void BtBitfieldMessageTest::testCreateMessage() {
 }
 
 void BtBitfieldMessageTest::testDoReceivedAction() {
-  SharedHandle<Peer> peer(new Peer("host1", 6969));
+  std::shared_ptr<Peer> peer(new Peer("host1", 6969));
   peer->allocateSessionResource(16*1024, 16*16*1024);
   BtBitfieldMessage msg;
   msg.setPeer(peer);
-  SharedHandle<MockPieceStorage> pieceStorage(new MockPieceStorage());
+  std::shared_ptr<MockPieceStorage> pieceStorage(new MockPieceStorage());
   msg.setPieceStorage(pieceStorage);
   unsigned char bitfield[] = { 0xff, 0xff };
   msg.setBitfield(bitfield, sizeof(bitfield));
@@ -99,11 +99,11 @@ void BtBitfieldMessageTest::testDoReceivedAction() {
 
 void BtBitfieldMessageTest::testDoReceivedAction_goodByeSeeder()
 {
-  SharedHandle<Peer> peer(new Peer("ip", 6000));
+  std::shared_ptr<Peer> peer(new Peer("ip", 6000));
   peer->allocateSessionResource(1024, 1024);
   BtBitfieldMessage msg;
   msg.setPeer(peer);
-  SharedHandle<MockPieceStorage> pieceStorage(new MockPieceStorage());
+  std::shared_ptr<MockPieceStorage> pieceStorage(new MockPieceStorage());
   msg.setPieceStorage(pieceStorage);
   unsigned char bitfield[] = { 0x00 };
   msg.setBitfield(bitfield, sizeof(bitfield));
diff --git a/test/BtCancelMessageTest.cc b/test/BtCancelMessageTest.cc
index e69e3269..e6dd3443 100644
--- a/test/BtCancelMessageTest.cc
+++ b/test/BtCancelMessageTest.cc
@@ -20,7 +20,7 @@ class BtCancelMessageTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testDoReceivedAction);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<Peer> peer;
+  std::shared_ptr<Peer> peer;
 public:
   void setUp() {
     peer.reset(new Peer("host", 6969));
@@ -58,7 +58,7 @@ void BtCancelMessageTest::testCreate() {
   bittorrent::setIntParam(&msg[5], 12345);
   bittorrent::setIntParam(&msg[9], 256);
   bittorrent::setIntParam(&msg[13], 1024);
-  SharedHandle<BtCancelMessage> pm(BtCancelMessage::create(&msg[4], 13));
+  std::shared_ptr<BtCancelMessage> pm(BtCancelMessage::create(&msg[4], 13));
   CPPUNIT_ASSERT_EQUAL((uint8_t)8, pm->getId());
   CPPUNIT_ASSERT_EQUAL((size_t)12345, pm->getIndex());
   CPPUNIT_ASSERT_EQUAL(256, pm->getBegin());
@@ -103,7 +103,7 @@ void BtCancelMessageTest::testDoReceivedAction() {
   msg.setBegin(2*16*1024);
   msg.setLength(16*1024);
   msg.setPeer(peer);
-  SharedHandle<MockBtMessageDispatcher2> dispatcher
+  std::shared_ptr<MockBtMessageDispatcher2> dispatcher
     (new MockBtMessageDispatcher2());
   msg.setBtMessageDispatcher(dispatcher.get());
 
diff --git a/test/BtChokeMessageTest.cc b/test/BtChokeMessageTest.cc
index 31e8bfe8..35dd6fa9 100644
--- a/test/BtChokeMessageTest.cc
+++ b/test/BtChokeMessageTest.cc
@@ -25,7 +25,7 @@ class BtChokeMessageTest:public CppUnit::TestFixture {
 private:
 
 public:
-  SharedHandle<Peer> peer;
+  std::shared_ptr<Peer> peer;
 
   void setUp() {
     peer.reset(new Peer("host", 6969));
@@ -72,7 +72,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BtChokeMessageTest);
 void BtChokeMessageTest::testCreate() {
   unsigned char msg[5];
   bittorrent::createPeerMessageString(msg, sizeof(msg), 1, 0);
-  SharedHandle<BtChokeMessage> pm(BtChokeMessage::create(&msg[4], 1));
+  std::shared_ptr<BtChokeMessage> pm(BtChokeMessage::create(&msg[4], 1));
   CPPUNIT_ASSERT_EQUAL((uint8_t)0, pm->getId());
 
   // case: payload size is wrong
@@ -106,9 +106,9 @@ void BtChokeMessageTest::testDoReceivedAction() {
   BtChokeMessage msg;
   msg.setPeer(peer);
 
-  SharedHandle<MockBtMessageDispatcher2> dispatcher(new MockBtMessageDispatcher2());
+  std::shared_ptr<MockBtMessageDispatcher2> dispatcher(new MockBtMessageDispatcher2());
   msg.setBtMessageDispatcher(dispatcher.get());
-  SharedHandle<MockBtRequestFactory2> requestFactory(new MockBtRequestFactory2());
+  std::shared_ptr<MockBtRequestFactory2> requestFactory(new MockBtRequestFactory2());
   msg.setBtRequestFactory(requestFactory.get());
 
   msg.doReceivedAction();
@@ -121,10 +121,10 @@ void BtChokeMessageTest::testOnSendComplete() {
   BtChokeMessage msg;
   msg.setPeer(peer);
 
-  SharedHandle<MockBtMessageDispatcher2> dispatcher(new MockBtMessageDispatcher2());
+  std::shared_ptr<MockBtMessageDispatcher2> dispatcher(new MockBtMessageDispatcher2());
   msg.setBtMessageDispatcher(dispatcher.get());
 
-  SharedHandle<ProgressUpdate> pu(msg.getProgressUpdate());
+  std::shared_ptr<ProgressUpdate> pu(msg.getProgressUpdate());
   pu->update(0, true);
 
   CPPUNIT_ASSERT(dispatcher->doChokingActionCalled);
diff --git a/test/BtDependencyTest.cc b/test/BtDependencyTest.cc
index 40823b0a..6fc9c9e8 100644
--- a/test/BtDependencyTest.cc
+++ b/test/BtDependencyTest.cc
@@ -36,37 +36,37 @@ class BtDependencyTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testResolve_dependeeInProgress);
   CPPUNIT_TEST_SUITE_END();
 
-  SharedHandle<RequestGroup> createDependant(const SharedHandle<Option>& option)
+  std::shared_ptr<RequestGroup> createDependant(const std::shared_ptr<Option>& option)
   {
-    SharedHandle<RequestGroup> dependant(new RequestGroup(GroupId::create(),
+    std::shared_ptr<RequestGroup> dependant(new RequestGroup(GroupId::create(),
                                                           util::copy(option)));
-    SharedHandle<DownloadContext> dctx
+    std::shared_ptr<DownloadContext> dctx
       (new DownloadContext(0, 0, "/tmp/outfile.path"));
     std::vector<std::string> uris;
     uris.push_back("http://localhost/outfile.path");
-    SharedHandle<FileEntry> fileEntry = dctx->getFirstFileEntry();
+    std::shared_ptr<FileEntry> fileEntry = dctx->getFirstFileEntry();
     fileEntry->setUris(uris);
     fileEntry->setOriginalName("aria2-0.8.2.tar.bz2");
     dependant->setDownloadContext(dctx);
     return dependant;
   }
 
-  SharedHandle<RequestGroup>
+  std::shared_ptr<RequestGroup>
   createDependee
-  (const SharedHandle<Option>& option,
+  (const std::shared_ptr<Option>& option,
    const std::string& torrentFile,
    int64_t length)
   {
-    SharedHandle<RequestGroup> dependee(new RequestGroup(GroupId::create(),
+    std::shared_ptr<RequestGroup> dependee(new RequestGroup(GroupId::create(),
                                                          util::copy(option)));
-    SharedHandle<DownloadContext> dctx
+    std::shared_ptr<DownloadContext> dctx
       (new DownloadContext(1024*1024, length, torrentFile));
     dependee->setDownloadContext(dctx);
     dependee->initPieceStorage();
     return dependee;
   }
 
-  SharedHandle<Option> option_;
+  std::shared_ptr<Option> option_;
 public:
   void setUp()
   {
@@ -91,8 +91,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION( BtDependencyTest );
 void BtDependencyTest::testResolve()
 {
   std::string filename = A2_TEST_DIR"/single.torrent";
-  SharedHandle<RequestGroup> dependant = createDependant(option_);
-  SharedHandle<RequestGroup> dependee =
+  std::shared_ptr<RequestGroup> dependant = createDependant(option_);
+  std::shared_ptr<RequestGroup> dependee =
     createDependee(option_, filename, File(filename).size());
   dependee->getPieceStorage()->getDiskAdaptor()->enableReadOnly();
   dependee->getPieceStorage()->markAllPiecesDone();
@@ -103,7 +103,7 @@ void BtDependencyTest::testResolve()
   CPPUNIT_ASSERT_EQUAL
     (std::string("cd41c7fdddfd034a15a04d7ff881216e01c4ceaf"),
      bittorrent::getInfoHashString(dependant->getDownloadContext()));
-  const SharedHandle<FileEntry>& firstFileEntry =
+  const std::shared_ptr<FileEntry>& firstFileEntry =
     dependant->getDownloadContext()->getFirstFileEntry();
   CPPUNIT_ASSERT_EQUAL(std::string("/tmp/outfile.path"),
                        firstFileEntry->getPath());
@@ -113,18 +113,18 @@ void BtDependencyTest::testResolve()
 
 void BtDependencyTest::testResolve_nullDependee()
 {
-  SharedHandle<RequestGroup> dependant = createDependant(option_);
-  BtDependency dep(dependant.get(), SharedHandle<RequestGroup>());
+  std::shared_ptr<RequestGroup> dependant = createDependant(option_);
+  BtDependency dep(dependant.get(), std::shared_ptr<RequestGroup>());
   CPPUNIT_ASSERT(dep.resolve());
 }
 
 void BtDependencyTest::testResolve_originalNameNoMatch()
 {
   std::string filename = A2_TEST_DIR"/single.torrent";
-  SharedHandle<RequestGroup> dependant = createDependant(option_);
+  std::shared_ptr<RequestGroup> dependant = createDependant(option_);
   dependant->getDownloadContext()->getFirstFileEntry()->setOriginalName
     ("aria2-1.1.0.tar.bz2");
-  SharedHandle<RequestGroup> dependee =
+  std::shared_ptr<RequestGroup> dependee =
     createDependee(option_, filename, File(filename).size());
   dependee->getPieceStorage()->getDiskAdaptor()->enableReadOnly();
   dependee->getPieceStorage()->markAllPiecesDone();
@@ -138,9 +138,9 @@ void BtDependencyTest::testResolve_originalNameNoMatch()
 void BtDependencyTest::testResolve_singleFileWithoutOriginalName()
 {
   std::string filename = A2_TEST_DIR"/single.torrent";
-  SharedHandle<RequestGroup> dependant = createDependant(option_);
+  std::shared_ptr<RequestGroup> dependant = createDependant(option_);
   dependant->getDownloadContext()->getFirstFileEntry()->setOriginalName("");
-  SharedHandle<RequestGroup> dependee =
+  std::shared_ptr<RequestGroup> dependee =
     createDependee(option_, filename, File(filename).size());
   dependee->getPieceStorage()->getDiskAdaptor()->enableReadOnly();
   dependee->getPieceStorage()->markAllPiecesDone();
@@ -152,10 +152,10 @@ void BtDependencyTest::testResolve_singleFileWithoutOriginalName()
 void BtDependencyTest::testResolve_multiFile()
 {
   std::string filename = A2_TEST_DIR"/test.torrent";
-  SharedHandle<RequestGroup> dependant = createDependant(option_);
+  std::shared_ptr<RequestGroup> dependant = createDependant(option_);
   dependant->getDownloadContext()->getFirstFileEntry()->setOriginalName
     ("aria2-test/aria2/src/aria2c");
-  SharedHandle<RequestGroup> dependee =
+  std::shared_ptr<RequestGroup> dependee =
     createDependee(option_, filename, File(filename).size());
   dependee->getPieceStorage()->getDiskAdaptor()->enableReadOnly();
   dependee->getPieceStorage()->markAllPiecesDone();
@@ -165,7 +165,7 @@ void BtDependencyTest::testResolve_multiFile()
 
   CPPUNIT_ASSERT(dependant->getDownloadContext()->hasAttribute(CTX_ATTR_BT));
 
-  const std::vector<SharedHandle<FileEntry> >& fileEntries =
+  const std::vector<std::shared_ptr<FileEntry> >& fileEntries =
     dependant->getDownloadContext()->getFileEntries();
   CPPUNIT_ASSERT_EQUAL(std::string("/tmp/outfile.path"),
                        fileEntries[0]->getPath());
@@ -177,22 +177,22 @@ void BtDependencyTest::testResolve_multiFile()
 
 void BtDependencyTest::testResolve_metadata()
 {
-  SharedHandle<RequestGroup> dependant = createDependant(option_);
-  SharedHandle<RequestGroup> dependee =
+  std::shared_ptr<RequestGroup> dependant = createDependant(option_);
+  std::shared_ptr<RequestGroup> dependee =
     createDependee(option_, "metadata", 0);
 
-  SharedHandle<DirectDiskAdaptor> diskAdaptor(new DirectDiskAdaptor());
-  SharedHandle<ByteArrayDiskWriter> diskWriter(new ByteArrayDiskWriter());
+  std::shared_ptr<DirectDiskAdaptor> diskAdaptor(new DirectDiskAdaptor());
+  std::shared_ptr<ByteArrayDiskWriter> diskWriter(new ByteArrayDiskWriter());
   diskAdaptor->setDiskWriter(diskWriter);
   diskWriter->setString
     ("d4:name19:aria2-0.8.2.tar.bz26:lengthi384e12:piece lengthi128e"
      "6:pieces60:AAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCC"
      "e");
-  SharedHandle<MockPieceStorage> pieceStorage(new MockPieceStorage());
+  std::shared_ptr<MockPieceStorage> pieceStorage(new MockPieceStorage());
   pieceStorage->setDiskAdaptor(diskAdaptor);
   pieceStorage->setDownloadFinished(true);
   dependee->setPieceStorage(pieceStorage);
-  SharedHandle<TorrentAttribute> attrs(new TorrentAttribute());
+  std::shared_ptr<TorrentAttribute> attrs(new TorrentAttribute());
   dependee->getDownloadContext()->setAttribute(CTX_ATTR_BT, attrs);
 
   BtDependency dep(dependant.get(), dependee);
@@ -207,8 +207,8 @@ void BtDependencyTest::testResolve_metadata()
 
 void BtDependencyTest::testResolve_loadError()
 {
-  SharedHandle<RequestGroup> dependant = createDependant(option_);
-  SharedHandle<RequestGroup> dependee =
+  std::shared_ptr<RequestGroup> dependant = createDependant(option_);
+  std::shared_ptr<RequestGroup> dependee =
     createDependee(option_, "notExist", 40);
   dependee->getPieceStorage()->markAllPiecesDone();
 
@@ -223,8 +223,8 @@ void BtDependencyTest::testResolve_loadError()
 
 void BtDependencyTest::testResolve_dependeeFailure()
 {
-  SharedHandle<RequestGroup> dependant = createDependant(option_);
-  SharedHandle<RequestGroup> dependee = createDependee(option_, "notExist", 40);
+  std::shared_ptr<RequestGroup> dependant = createDependant(option_);
+  std::shared_ptr<RequestGroup> dependee = createDependee(option_, "notExist", 40);
 
   BtDependency dep(dependant.get(), dependee);
   CPPUNIT_ASSERT(dep.resolve());
@@ -238,8 +238,8 @@ void BtDependencyTest::testResolve_dependeeFailure()
 void BtDependencyTest::testResolve_dependeeInProgress()
 {
   std::string filename = A2_TEST_DIR"/single.torrent";
-  SharedHandle<RequestGroup> dependant = createDependant(option_);
-  SharedHandle<RequestGroup> dependee =
+  std::shared_ptr<RequestGroup> dependant = createDependant(option_);
+  std::shared_ptr<RequestGroup> dependee =
     createDependee(option_, filename, File(filename).size());
   dependee->increaseNumCommand();
 
diff --git a/test/BtExtendedMessageTest.cc b/test/BtExtendedMessageTest.cc
index f12e4343..a459e287 100644
--- a/test/BtExtendedMessageTest.cc
+++ b/test/BtExtendedMessageTest.cc
@@ -33,10 +33,10 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION(BtExtendedMessageTest);
 
 void BtExtendedMessageTest::testCreate() {
-  SharedHandle<Peer> peer(new Peer("192.168.0.1", 6969));
+  std::shared_ptr<Peer> peer(new Peer("192.168.0.1", 6969));
   peer->allocateSessionResource(1024, 1024*1024);
 
-  SharedHandle<MockExtensionMessageFactory> exmsgFactory
+  std::shared_ptr<MockExtensionMessageFactory> exmsgFactory
     (new MockExtensionMessageFactory());
 
   // payload:{4:name3:foo}->11bytes
@@ -45,7 +45,7 @@ void BtExtendedMessageTest::testCreate() {
   bittorrent::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());
-  SharedHandle<BtExtendedMessage> pm(BtExtendedMessage::create(exmsgFactory,
+  std::shared_ptr<BtExtendedMessage> pm(BtExtendedMessage::create(exmsgFactory,
                                                                peer,
                                                                &msg[4], 13));
   CPPUNIT_ASSERT_EQUAL((uint8_t)20, pm->getId());
@@ -73,7 +73,7 @@ void BtExtendedMessageTest::testCreate() {
 void BtExtendedMessageTest::testCreateMessage() {
   std::string payload = "4:name3:foo";
   uint8_t extendedMessageID = 1;
-  SharedHandle<MockExtensionMessage> exmsg
+  std::shared_ptr<MockExtensionMessage> exmsg
     (new MockExtensionMessage("charlie", extendedMessageID, payload));
   BtExtendedMessage msg(exmsg);
 
@@ -88,7 +88,7 @@ void BtExtendedMessageTest::testCreateMessage() {
 }
 
 void BtExtendedMessageTest::testDoReceivedAction() {
-  SharedHandle<MockExtensionMessage> exmsg
+  std::shared_ptr<MockExtensionMessage> exmsg
     (new MockExtensionMessage("charlie", 1, ""));
   BtExtendedMessage msg(exmsg);
   msg.doReceivedAction();
@@ -98,7 +98,7 @@ void BtExtendedMessageTest::testDoReceivedAction() {
 void BtExtendedMessageTest::testToString() {
   std::string payload = "4:name3:foo";
   uint8_t extendedMessageID = 1;
-  SharedHandle<MockExtensionMessage> exmsg
+  std::shared_ptr<MockExtensionMessage> exmsg
     (new MockExtensionMessage("charlie", extendedMessageID, payload));
   BtExtendedMessage msg(exmsg);
   CPPUNIT_ASSERT_EQUAL(std::string("extended charlie"), msg.toString());
diff --git a/test/BtHandshakeMessageTest.cc b/test/BtHandshakeMessageTest.cc
index 165a0d19..f8c17acc 100644
--- a/test/BtHandshakeMessageTest.cc
+++ b/test/BtHandshakeMessageTest.cc
@@ -57,7 +57,7 @@ void createHandshakeMessageData(unsigned char* msg) {
 void BtHandshakeMessageTest::testCreate() {
   unsigned char msg[68];
   createHandshakeMessageData(msg);
-  SharedHandle<BtHandshakeMessage> message = BtHandshakeMessage::create(&msg[0], sizeof(msg));
+  std::shared_ptr<BtHandshakeMessage> message = BtHandshakeMessage::create(&msg[0], sizeof(msg));
   CPPUNIT_ASSERT_EQUAL((uint8_t)INT8_MAX, message->getId());
   CPPUNIT_ASSERT_EQUAL((uint8_t)19, message->getPstrlen());
   CPPUNIT_ASSERT_EQUAL(util::toHex((const unsigned char*)BTPSTR.c_str(), BTPSTR.size()),
@@ -80,7 +80,7 @@ void BtHandshakeMessageTest::testCreateMessage() {
                              0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
                              0xf0, 0xf0, 0xf0, 0xf0, 0xf0 };
 
-  SharedHandle<BtHandshakeMessage> msg(new BtHandshakeMessage());
+  std::shared_ptr<BtHandshakeMessage> msg(new BtHandshakeMessage());
   msg->setInfoHash(infoHash);
   msg->setPeerId(peerId);
 
diff --git a/test/BtHaveAllMessageTest.cc b/test/BtHaveAllMessageTest.cc
index c86ef691..0b6a9e92 100644
--- a/test/BtHaveAllMessageTest.cc
+++ b/test/BtHaveAllMessageTest.cc
@@ -38,7 +38,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BtHaveAllMessageTest);
 void BtHaveAllMessageTest::testCreate() {
   unsigned char msg[5];
   bittorrent::createPeerMessageString(msg, sizeof(msg), 1, 14);
-  SharedHandle<BtHaveAllMessage> pm(BtHaveAllMessage::create(&msg[4], 1));
+  std::shared_ptr<BtHaveAllMessage> pm(BtHaveAllMessage::create(&msg[4], 1));
   CPPUNIT_ASSERT_EQUAL((uint8_t)14, pm->getId());
 
   // case: payload size is wrong
@@ -70,11 +70,11 @@ void BtHaveAllMessageTest::testCreateMessage() {
 
 void BtHaveAllMessageTest::testDoReceivedAction() {
   BtHaveAllMessage msg;
-  SharedHandle<Peer> peer(new Peer("host", 6969));
+  std::shared_ptr<Peer> peer(new Peer("host", 6969));
   peer->allocateSessionResource(16*1024, 256*1024);
   peer->setFastExtensionEnabled(true);
   msg.setPeer(peer);
-  SharedHandle<MockPieceStorage> pieceStorage(new MockPieceStorage());
+  std::shared_ptr<MockPieceStorage> pieceStorage(new MockPieceStorage());
   msg.setPieceStorage(pieceStorage);
 
   msg.doReceivedAction();
@@ -92,11 +92,11 @@ void BtHaveAllMessageTest::testDoReceivedAction() {
 void BtHaveAllMessageTest::testDoReceivedAction_goodByeSeeder()
 {
   BtHaveAllMessage msg;
-  SharedHandle<Peer> peer(new Peer("ip", 6000));
+  std::shared_ptr<Peer> peer(new Peer("ip", 6000));
   peer->allocateSessionResource(1024, 1024);
   peer->setFastExtensionEnabled(true);
   msg.setPeer(peer);
-  SharedHandle<MockPieceStorage> pieceStorage(new MockPieceStorage());
+  std::shared_ptr<MockPieceStorage> pieceStorage(new MockPieceStorage());
   msg.setPieceStorage(pieceStorage);
 
   pieceStorage->setDownloadFinished(true);
diff --git a/test/BtHaveMessageTest.cc b/test/BtHaveMessageTest.cc
index 5c1c7e2a..15072e24 100644
--- a/test/BtHaveMessageTest.cc
+++ b/test/BtHaveMessageTest.cc
@@ -41,7 +41,7 @@ void BtHaveMessageTest::testCreate() {
   unsigned char msg[9];
   bittorrent::createPeerMessageString(msg, sizeof(msg), 5, 4);
   bittorrent::setIntParam(&msg[5], 12345);
-  SharedHandle<BtHaveMessage> pm(BtHaveMessage::create(&msg[4], 5));
+  std::shared_ptr<BtHaveMessage> pm(BtHaveMessage::create(&msg[4], 5));
   CPPUNIT_ASSERT_EQUAL((uint8_t)4, pm->getId());
   CPPUNIT_ASSERT_EQUAL((size_t)12345, pm->getIndex());
 
@@ -75,12 +75,12 @@ void BtHaveMessageTest::testCreateMessage() {
 }
 
 void BtHaveMessageTest::testDoReceivedAction() {
-  SharedHandle<Peer> peer(new Peer("host", 6969));
+  std::shared_ptr<Peer> peer(new Peer("host", 6969));
   peer->allocateSessionResource(16*1024, 256*1024);
   BtHaveMessage msg;
   msg.setIndex(1);
   msg.setPeer(peer);
-  SharedHandle<MockPieceStorage> pieceStorage(new MockPieceStorage());
+  std::shared_ptr<MockPieceStorage> pieceStorage(new MockPieceStorage());
   msg.setPieceStorage(pieceStorage);
 
   CPPUNIT_ASSERT(!peer->hasPiece(msg.getIndex()));
@@ -92,12 +92,12 @@ void BtHaveMessageTest::testDoReceivedAction() {
 
 void BtHaveMessageTest::testDoReceivedAction_goodByeSeeder()
 {
-  SharedHandle<Peer> peer(new Peer("ip", 6000));
+  std::shared_ptr<Peer> peer(new Peer("ip", 6000));
   peer->allocateSessionResource(1024, 2*1024);
   BtHaveMessage msg;
   msg.setIndex(0);
   msg.setPeer(peer);
-  SharedHandle<MockPieceStorage> pieceStorage(new MockPieceStorage());
+  std::shared_ptr<MockPieceStorage> pieceStorage(new MockPieceStorage());
   msg.setPieceStorage(pieceStorage);
 
   // peer is not seeder and client have not completed download
diff --git a/test/BtHaveNoneMessageTest.cc b/test/BtHaveNoneMessageTest.cc
index 50fff402..7f049780 100644
--- a/test/BtHaveNoneMessageTest.cc
+++ b/test/BtHaveNoneMessageTest.cc
@@ -35,7 +35,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BtHaveNoneMessageTest);
 void BtHaveNoneMessageTest::testCreate() {
   unsigned char msg[5];
   bittorrent::createPeerMessageString(msg, sizeof(msg), 1, 15);
-  SharedHandle<BtHaveNoneMessage> pm(BtHaveNoneMessage::create(&msg[4], 1));
+  std::shared_ptr<BtHaveNoneMessage> pm(BtHaveNoneMessage::create(&msg[4], 1));
   CPPUNIT_ASSERT_EQUAL((uint8_t)15, pm->getId());
 
   // case: payload size is wrong
@@ -67,7 +67,7 @@ void BtHaveNoneMessageTest::testCreateMessage() {
 
 void BtHaveNoneMessageTest::testDoReceivedAction() {
   BtHaveNoneMessage msg;
-  SharedHandle<Peer> peer(new Peer("host", 6969));
+  std::shared_ptr<Peer> peer(new Peer("host", 6969));
   peer->allocateSessionResource(1024, 1024*1024);
   peer->setFastExtensionEnabled(true);
   msg.setPeer(peer);
diff --git a/test/BtInterestedMessageTest.cc b/test/BtInterestedMessageTest.cc
index ccb6b8b2..0cf47318 100644
--- a/test/BtInterestedMessageTest.cc
+++ b/test/BtInterestedMessageTest.cc
@@ -34,7 +34,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BtInterestedMessageTest);
 void BtInterestedMessageTest::testCreate() {
   unsigned char msg[5];
   bittorrent::createPeerMessageString(msg, sizeof(msg), 1, 2);
-  SharedHandle<BtInterestedMessage> pm
+  std::shared_ptr<BtInterestedMessage> pm
     (BtInterestedMessage::create(&msg[4], 1));
   CPPUNIT_ASSERT_EQUAL((uint8_t)2, pm->getId());
 
@@ -67,11 +67,11 @@ void BtInterestedMessageTest::testCreateMessage() {
 
 void BtInterestedMessageTest::testDoReceivedAction() {
   BtInterestedMessage msg;
-  SharedHandle<Peer> peer(new Peer("host", 6969));
+  std::shared_ptr<Peer> peer(new Peer("host", 6969));
   peer->allocateSessionResource(1024, 1024*1024);
   msg.setPeer(peer);
 
-  SharedHandle<MockPeerStorage> peerStorage(new MockPeerStorage());
+  std::shared_ptr<MockPeerStorage> peerStorage(new MockPeerStorage());
 
   msg.setPeerStorage(peerStorage);
 
@@ -87,11 +87,11 @@ void BtInterestedMessageTest::testDoReceivedAction() {
 
 void BtInterestedMessageTest::testOnSendComplete() {
   BtInterestedMessage msg;
-  SharedHandle<Peer> peer(new Peer("host", 6969));
+  std::shared_ptr<Peer> peer(new Peer("host", 6969));
   peer->allocateSessionResource(1024, 1024*1024);
   msg.setPeer(peer);
   CPPUNIT_ASSERT(!peer->amInterested());
-  SharedHandle<ProgressUpdate> pu(msg.getProgressUpdate());
+  std::shared_ptr<ProgressUpdate> pu(msg.getProgressUpdate());
   pu->update(0, true);
   CPPUNIT_ASSERT(peer->amInterested());
 }
diff --git a/test/BtNotInterestedMessageTest.cc b/test/BtNotInterestedMessageTest.cc
index 1bd204d0..01c1727e 100644
--- a/test/BtNotInterestedMessageTest.cc
+++ b/test/BtNotInterestedMessageTest.cc
@@ -34,7 +34,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BtNotInterestedMessageTest);
 void BtNotInterestedMessageTest::testCreate() {
   unsigned char msg[5];
   bittorrent::createPeerMessageString(msg, sizeof(msg), 1, 3);
-  SharedHandle<BtNotInterestedMessage> pm
+  std::shared_ptr<BtNotInterestedMessage> pm
     (BtNotInterestedMessage::create(&msg[4], 1));
   CPPUNIT_ASSERT_EQUAL((uint8_t)3, pm->getId());
 
@@ -66,11 +66,11 @@ void BtNotInterestedMessageTest::testCreateMessage() {
 }
 
 void BtNotInterestedMessageTest::testDoReceivedAction() {
-  SharedHandle<Peer> peer(new Peer("host", 6969));
+  std::shared_ptr<Peer> peer(new Peer("host", 6969));
   peer->allocateSessionResource(1024, 1024*1024);
   peer->peerInterested(true);
 
-  SharedHandle<MockPeerStorage> peerStorage(new MockPeerStorage());
+  std::shared_ptr<MockPeerStorage> peerStorage(new MockPeerStorage());
 
   BtNotInterestedMessage msg;
   msg.setPeer(peer);
@@ -87,13 +87,13 @@ void BtNotInterestedMessageTest::testDoReceivedAction() {
 }
 
 void BtNotInterestedMessageTest::testOnSendComplete() {
-  SharedHandle<Peer> peer(new Peer("host", 6969));
+  std::shared_ptr<Peer> peer(new Peer("host", 6969));
   peer->allocateSessionResource(1024, 1024*1024);
   peer->amInterested(true);
   BtNotInterestedMessage msg;
   msg.setPeer(peer);
   CPPUNIT_ASSERT(peer->amInterested());
-  SharedHandle<ProgressUpdate> pu(msg.getProgressUpdate());
+  std::shared_ptr<ProgressUpdate> pu(msg.getProgressUpdate());
   pu->update(0, true);
   CPPUNIT_ASSERT(!peer->amInterested());
 }
diff --git a/test/BtPieceMessageTest.cc b/test/BtPieceMessageTest.cc
index 205e0dbd..fc88fc84 100644
--- a/test/BtPieceMessageTest.cc
+++ b/test/BtPieceMessageTest.cc
@@ -59,20 +59,20 @@ public:
 
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual SharedHandle<BtMessage>
+    virtual std::shared_ptr<BtMessage>
     createRejectMessage(size_t index,
                         int32_t begin,
                         int32_t length) {
-      SharedHandle<MockBtMessage2> msg(new MockBtMessage2(index, begin, length));
+      std::shared_ptr<MockBtMessage2> msg(new MockBtMessage2(index, begin, length));
       return msg;
     }
   };
 
-  SharedHandle<DownloadContext> dctx_;
-  SharedHandle<MockBtMessageDispatcher> btMessageDispatcher;
-  SharedHandle<MockBtMessageFactory> btMessageFactory_;
-  SharedHandle<Peer> peer;
-  SharedHandle<BtPieceMessage> msg;
+  std::shared_ptr<DownloadContext> dctx_;
+  std::shared_ptr<MockBtMessageDispatcher> btMessageDispatcher;
+  std::shared_ptr<MockBtMessageFactory> btMessageFactory_;
+  std::shared_ptr<Peer> peer;
+  std::shared_ptr<BtPieceMessage> msg;
 
   void setUp() {
     dctx_.reset(new DownloadContext(16*1024, 256*1024, "/path/to/file"));
@@ -106,7 +106,7 @@ void BtPieceMessageTest::testCreate() {
   bittorrent::setIntParam(&msg[5], 12345);
   bittorrent::setIntParam(&msg[9], 256);
   memcpy(&msg[13], data, sizeof(data));
-  SharedHandle<BtPieceMessage> pm(BtPieceMessage::create(&msg[4], 11));
+  std::shared_ptr<BtPieceMessage> pm(BtPieceMessage::create(&msg[4], 11));
   CPPUNIT_ASSERT_EQUAL((uint8_t)7, pm->getId());
   CPPUNIT_ASSERT_EQUAL((size_t)12345, pm->getIndex());
   CPPUNIT_ASSERT_EQUAL(256, pm->getBegin());
@@ -166,8 +166,7 @@ void BtPieceMessageTest::testChokingEvent_allowedFastEnabled() {
 
   CPPUNIT_ASSERT(msg->isInvalidate());
   CPPUNIT_ASSERT_EQUAL((size_t)1, btMessageDispatcher->messageQueue.size());
-  SharedHandle<MockBtMessage2> rej =
-    dynamic_pointer_cast<MockBtMessage2>
+  auto rej = std::dynamic_pointer_cast<MockBtMessage2>
     (btMessageDispatcher->messageQueue.front());
   CPPUNIT_ASSERT_EQUAL((size_t)1, rej->index);
   CPPUNIT_ASSERT_EQUAL((uint32_t)1024, rej->begin);
@@ -235,8 +234,7 @@ void BtPieceMessageTest::testCancelSendingPieceEvent_allowedFastEnabled() {
 
   CPPUNIT_ASSERT(msg->isInvalidate());
   CPPUNIT_ASSERT_EQUAL((size_t)1, btMessageDispatcher->messageQueue.size());
-  SharedHandle<MockBtMessage2> rej =
-    dynamic_pointer_cast<MockBtMessage2>
+  auto rej = std::dynamic_pointer_cast<MockBtMessage2>
     (btMessageDispatcher->messageQueue.front());
   CPPUNIT_ASSERT_EQUAL((size_t)1, rej->index);
   CPPUNIT_ASSERT_EQUAL((uint32_t)1024, rej->begin);
diff --git a/test/BtPortMessageTest.cc b/test/BtPortMessageTest.cc
index dff262f3..a2675b59 100644
--- a/test/BtPortMessageTest.cc
+++ b/test/BtPortMessageTest.cc
@@ -39,16 +39,16 @@ public:
 
   class MockDHTTaskFactory2:public MockDHTTaskFactory {
   public:
-    virtual SharedHandle<DHTTask>
-    createPingTask(const SharedHandle<DHTNode>& remoteNode, int numRetry)
+    virtual std::shared_ptr<DHTTask>
+    createPingTask(const std::shared_ptr<DHTNode>& remoteNode, int numRetry)
     {
-      return SharedHandle<DHTTask>(new MockDHTTask(remoteNode));
+      return std::shared_ptr<DHTTask>(new MockDHTTask(remoteNode));
     }
 
-    virtual SharedHandle<DHTTask>
+    virtual std::shared_ptr<DHTTask>
     createNodeLookupTask(const unsigned char* targetID)
     {
-      SharedHandle<MockDHTTask> task(new MockDHTTask(SharedHandle<DHTNode>()));
+      std::shared_ptr<MockDHTTask> task(new MockDHTTask(std::shared_ptr<DHTNode>()));
       task->setTargetID(targetID);
       return task;
     }
@@ -62,7 +62,7 @@ void BtPortMessageTest::testCreate() {
   unsigned char msg[7];
   bittorrent::createPeerMessageString(msg, sizeof(msg), 3, 9);
   bittorrent::setShortIntParam(&msg[5], 12345);
-  SharedHandle<BtPortMessage> pm(BtPortMessage::create(&msg[4], 3));
+  std::shared_ptr<BtPortMessage> pm(BtPortMessage::create(&msg[4], 3));
   CPPUNIT_ASSERT_EQUAL((uint8_t)9, pm->getId());
   CPPUNIT_ASSERT_EQUAL((uint16_t)12345, pm->getPort());
 
@@ -103,10 +103,10 @@ void BtPortMessageTest::testDoReceivedAction()
 {
   unsigned char nodeID[DHT_ID_LENGTH];
   memset(nodeID, 0, DHT_ID_LENGTH);
-  SharedHandle<DHTNode> localNode(new DHTNode(nodeID));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(nodeID));
 
   // 9 nodes to create at least 2 buckets.
-  SharedHandle<DHTNode> nodes[9];
+  std::shared_ptr<DHTNode> nodes[9];
   for(size_t i = 0; i < A2_ARRAY_LEN(nodes); ++i) {
     memset(nodeID, 0, DHT_ID_LENGTH);
     nodeID[DHT_ID_LENGTH-1] = i+1;
@@ -118,7 +118,7 @@ void BtPortMessageTest::testDoReceivedAction()
     routingTable.addNode(nodes[i]);
   }
 
-  SharedHandle<Peer> peer(new Peer("192.168.0.1", 6881));
+  std::shared_ptr<Peer> peer(new Peer("192.168.0.1", 6881));
   BtPortMessage msg(6881);
   MockDHTTaskQueue taskQueue;
   MockDHTTaskFactory2 taskFactory;
@@ -132,9 +132,9 @@ void BtPortMessageTest::testDoReceivedAction()
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, taskQueue.immediateTaskQueue_.size());
 
-  SharedHandle<MockDHTTask> task
-    (dynamic_pointer_cast<MockDHTTask>(taskQueue.immediateTaskQueue_[0]));
-  SharedHandle<DHTNode> node = task->remoteNode_;
+  auto task = std::dynamic_pointer_cast<MockDHTTask>
+    (taskQueue.immediateTaskQueue_[0]);
+  std::shared_ptr<DHTNode> node = task->remoteNode_;
   CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), node->getIPAddress());
   CPPUNIT_ASSERT_EQUAL((uint16_t)6881, node->getPort());
 }
@@ -144,10 +144,10 @@ void BtPortMessageTest::testDoReceivedAction_bootstrap()
   unsigned char nodeID[DHT_ID_LENGTH];
   memset(nodeID, 0, DHT_ID_LENGTH);
   nodeID[0] = 0xff;
-  SharedHandle<DHTNode> localNode(new DHTNode(nodeID));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(nodeID));
   DHTRoutingTable routingTable(localNode); // no nodes , 1 bucket.
 
-  SharedHandle<Peer> peer(new Peer("192.168.0.1", 6881));
+  std::shared_ptr<Peer> peer(new Peer("192.168.0.1", 6881));
   BtPortMessage msg(6881);
   MockDHTTaskQueue taskQueue;
   MockDHTTaskFactory2 taskFactory;
@@ -160,14 +160,14 @@ void BtPortMessageTest::testDoReceivedAction_bootstrap()
   msg.doReceivedAction();
 
   CPPUNIT_ASSERT_EQUAL((size_t)2, taskQueue.immediateTaskQueue_.size());
-  SharedHandle<MockDHTTask> task
-    (dynamic_pointer_cast<MockDHTTask>(taskQueue.immediateTaskQueue_[0]));
-  SharedHandle<DHTNode> node(task->remoteNode_);
+  auto task = std::dynamic_pointer_cast<MockDHTTask>
+    (taskQueue.immediateTaskQueue_[0]);
+  std::shared_ptr<DHTNode> node(task->remoteNode_);
   CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), node->getIPAddress());
   CPPUNIT_ASSERT_EQUAL((uint16_t)6881, node->getPort());
 
-  SharedHandle<MockDHTTask> task2
-    (dynamic_pointer_cast<MockDHTTask>(taskQueue.immediateTaskQueue_[1]));
+  auto task2 = std::dynamic_pointer_cast<MockDHTTask>
+    (taskQueue.immediateTaskQueue_[1]);
   CPPUNIT_ASSERT(memcmp(nodeID, task2->targetID_, DHT_ID_LENGTH) == 0);
 }
 
diff --git a/test/BtPostDownloadHandlerTest.cc b/test/BtPostDownloadHandlerTest.cc
index 3b5e39e6..6e1c36ad 100644
--- a/test/BtPostDownloadHandlerTest.cc
+++ b/test/BtPostDownloadHandlerTest.cc
@@ -20,7 +20,7 @@ class BtPostDownloadHandlerTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testGetNextRequestGroups);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<Option> option_;
+  std::shared_ptr<Option> option_;
 public:
   void setUp()
   {
@@ -37,7 +37,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( BtPostDownloadHandlerTest );
 
 void BtPostDownloadHandlerTest::testCanHandle_extension()
 {
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(0, 0, A2_TEST_DIR"/test.torrent"));
   RequestGroup rg(GroupId::create(), option_);
   rg.setDownloadContext(dctx);
@@ -52,7 +52,7 @@ void BtPostDownloadHandlerTest::testCanHandle_extension()
 
 void BtPostDownloadHandlerTest::testCanHandle_contentType()
 {
-  SharedHandle<DownloadContext> dctx(new DownloadContext(0, 0, "test"));
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext(0, 0, "test"));
   dctx->getFirstFileEntry()->setContentType("application/x-bittorrent");
   RequestGroup rg(GroupId::create(), option_);
   rg.setDownloadContext(dctx);
@@ -67,7 +67,7 @@ void BtPostDownloadHandlerTest::testCanHandle_contentType()
 
 void BtPostDownloadHandlerTest::testGetNextRequestGroups()
 {
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(1024, 0, A2_TEST_DIR"/test.torrent"));
   RequestGroup rg(GroupId::create(), option_);
   rg.setDownloadContext(dctx);
@@ -75,7 +75,7 @@ void BtPostDownloadHandlerTest::testGetNextRequestGroups()
   rg.getPieceStorage()->getDiskAdaptor()->enableReadOnly();
 
   BtPostDownloadHandler handler;
-  std::vector<SharedHandle<RequestGroup> > groups;
+  std::vector<std::shared_ptr<RequestGroup> > groups;
   handler.getNextRequestGroups(groups, &rg);
   CPPUNIT_ASSERT_EQUAL((size_t)1, groups.size());
   CPPUNIT_ASSERT_EQUAL
diff --git a/test/BtRegistryTest.cc b/test/BtRegistryTest.cc
index b66557bf..7bbd40e3 100644
--- a/test/BtRegistryTest.cc
+++ b/test/BtRegistryTest.cc
@@ -41,8 +41,8 @@ void BtRegistryTest::testGetDownloadContext()
 {
   BtRegistry btRegistry;
   CPPUNIT_ASSERT(!btRegistry.getDownloadContext(1));
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
-  SharedHandle<BtObject> btObject(new BtObject());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<BtObject> btObject(new BtObject());
   btObject->downloadContext = dctx;
   btRegistry.put(1, btObject);
   CPPUNIT_ASSERT_EQUAL(dctx.get(), btRegistry.getDownloadContext(1).get());
@@ -51,11 +51,11 @@ void BtRegistryTest::testGetDownloadContext()
 namespace {
 void addTwoDownloadContext(BtRegistry& btRegistry)
 {
-  SharedHandle<DownloadContext> dctx1(new DownloadContext());
-  SharedHandle<DownloadContext> dctx2(new DownloadContext());
-  SharedHandle<BtObject> btObject1(new BtObject());
+  std::shared_ptr<DownloadContext> dctx1(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx2(new DownloadContext());
+  std::shared_ptr<BtObject> btObject1(new BtObject());
   btObject1->downloadContext = dctx1;
-  SharedHandle<BtObject> btObject2(new BtObject());
+  std::shared_ptr<BtObject> btObject2(new BtObject());
   btObject2->downloadContext = dctx2;
   btRegistry.put(1, btObject1);
   btRegistry.put(2, btObject2);
@@ -66,9 +66,9 @@ void BtRegistryTest::testGetDownloadContext_infoHash()
 {
   BtRegistry btRegistry;
   addTwoDownloadContext(btRegistry);
-  SharedHandle<TorrentAttribute> attrs1(new TorrentAttribute());
+  std::shared_ptr<TorrentAttribute> attrs1(new TorrentAttribute());
   attrs1->infoHash = "hash1";
-  SharedHandle<TorrentAttribute> attrs2(new TorrentAttribute());
+  std::shared_ptr<TorrentAttribute> attrs2(new TorrentAttribute());
   attrs2->infoHash = "hash2";
   btRegistry.getDownloadContext(1)->setAttribute(CTX_ATTR_BT, attrs1);
   btRegistry.getDownloadContext(2)->setAttribute(CTX_ATTR_BT, attrs2);
@@ -84,7 +84,7 @@ void BtRegistryTest::testGetAllDownloadContext()
   BtRegistry btRegistry;
   addTwoDownloadContext(btRegistry);
 
-  std::vector<SharedHandle<DownloadContext> > result;
+  std::vector<std::shared_ptr<DownloadContext> > result;
   btRegistry.getAllDownloadContext(std::back_inserter(result));
   CPPUNIT_ASSERT_EQUAL((size_t)2, result.size());
 }
diff --git a/test/BtRejectMessageTest.cc b/test/BtRejectMessageTest.cc
index c9f55fec..cd809ced 100644
--- a/test/BtRejectMessageTest.cc
+++ b/test/BtRejectMessageTest.cc
@@ -60,11 +60,11 @@ public:
     }
   };
 
-  typedef SharedHandle<MockBtMessageDispatcher2> MockBtMessageDispatcher2Handle;
+  typedef std::shared_ptr<MockBtMessageDispatcher2> MockBtMessageDispatcher2Handle;
 
-  SharedHandle<Peer> peer;
-  SharedHandle<MockBtMessageDispatcher2> dispatcher;
-  SharedHandle<BtRejectMessage> msg;
+  std::shared_ptr<Peer> peer;
+  std::shared_ptr<MockBtMessageDispatcher2> dispatcher;
+  std::shared_ptr<BtRejectMessage> msg;
 
   void setUp() {
     peer.reset(new Peer("host", 6969));
@@ -90,7 +90,7 @@ void BtRejectMessageTest::testCreate() {
   bittorrent::setIntParam(&msg[5], 12345);
   bittorrent::setIntParam(&msg[9], 256);
   bittorrent::setIntParam(&msg[13], 1024);
-  SharedHandle<BtRejectMessage> pm(BtRejectMessage::create(&msg[4], 13));
+  std::shared_ptr<BtRejectMessage> pm(BtRejectMessage::create(&msg[4], 13));
   CPPUNIT_ASSERT_EQUAL((uint8_t)16, pm->getId());
   CPPUNIT_ASSERT_EQUAL((size_t)12345, pm->getIndex());
   CPPUNIT_ASSERT_EQUAL(256, pm->getBegin());
diff --git a/test/BtRequestMessageTest.cc b/test/BtRequestMessageTest.cc
index c54e6212..623851e4 100644
--- a/test/BtRequestMessageTest.cc
+++ b/test/BtRequestMessageTest.cc
@@ -72,32 +72,32 @@ public:
       type(type), index(index), begin(begin), length(length) {}
   };
 
-  typedef SharedHandle<MockBtMessage2> MockBtMessage2Handle;
+  typedef std::shared_ptr<MockBtMessage2> MockBtMessage2Handle;
 
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual SharedHandle<BtMessage>
+    virtual std::shared_ptr<BtMessage>
     createPieceMessage(size_t index, int32_t begin, int32_t length) {
-      SharedHandle<MockBtMessage2> btMsg
+      std::shared_ptr<MockBtMessage2> btMsg
         (new MockBtMessage2("piece", index, begin, length));
       return btMsg;
     }
 
-    virtual SharedHandle<BtMessage>
+    virtual std::shared_ptr<BtMessage>
     createRejectMessage(size_t index, int32_t begin, int32_t length) {
-      SharedHandle<MockBtMessage2> btMsg
+      std::shared_ptr<MockBtMessage2> btMsg
         (new MockBtMessage2("reject", index, begin, length));
       return btMsg;
     }
   };
 
-  typedef SharedHandle<MockBtMessageFactory2> MockBtMessageFactory2Handle;
+  typedef std::shared_ptr<MockBtMessageFactory2> MockBtMessageFactory2Handle;
 
-  SharedHandle<MockPieceStorage> pieceStorage_;
-  SharedHandle<Peer> peer_;
-  SharedHandle<MockBtMessageDispatcher> dispatcher_;
-  SharedHandle<MockBtMessageFactory> messageFactory_;
-  SharedHandle<BtRequestMessage> msg;
+  std::shared_ptr<MockPieceStorage> pieceStorage_;
+  std::shared_ptr<Peer> peer_;
+  std::shared_ptr<MockBtMessageDispatcher> dispatcher_;
+  std::shared_ptr<MockBtMessageFactory> messageFactory_;
+  std::shared_ptr<BtRequestMessage> msg;
 
   void setUp() {
     pieceStorage_.reset(new MockPieceStorage2());
@@ -130,7 +130,7 @@ void BtRequestMessageTest::testCreate() {
   bittorrent::setIntParam(&msg[5], 12345);
   bittorrent::setIntParam(&msg[9], 256);
   bittorrent::setIntParam(&msg[13], 1024);
-  SharedHandle<BtRequestMessage> pm(BtRequestMessage::create(&msg[4], 13));
+  std::shared_ptr<BtRequestMessage> pm(BtRequestMessage::create(&msg[4], 13));
   CPPUNIT_ASSERT_EQUAL((uint8_t)6, pm->getId());
   CPPUNIT_ASSERT_EQUAL((size_t)12345, pm->getIndex());
   CPPUNIT_ASSERT_EQUAL(256, pm->getBegin());
@@ -174,8 +174,8 @@ void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmNotChoking() {
   msg->doReceivedAction();
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher_->messageQueue.size());
-  SharedHandle<MockBtMessage2> pieceMsg =
-    dynamic_pointer_cast<MockBtMessage2>(dispatcher_->messageQueue.front());
+  auto pieceMsg = std::dynamic_pointer_cast<MockBtMessage2>
+    (dispatcher_->messageQueue.front());
   CPPUNIT_ASSERT_EQUAL(std::string("piece"), pieceMsg->type);
   CPPUNIT_ASSERT_EQUAL((size_t)1, pieceMsg->index);
   CPPUNIT_ASSERT_EQUAL((uint32_t)16, pieceMsg->begin);
@@ -188,8 +188,8 @@ void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmChokingAndFastExten
   msg->doReceivedAction();
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher_->messageQueue.size());
-  SharedHandle<MockBtMessage2> pieceMsg =
-    dynamic_pointer_cast<MockBtMessage2>(dispatcher_->messageQueue.front());
+  auto pieceMsg = std::dynamic_pointer_cast<MockBtMessage2>
+    (dispatcher_->messageQueue.front());
   CPPUNIT_ASSERT_EQUAL(std::string("reject"), pieceMsg->type);
   CPPUNIT_ASSERT_EQUAL((size_t)1, pieceMsg->index);
   CPPUNIT_ASSERT_EQUAL((uint32_t)16, pieceMsg->begin);
@@ -210,8 +210,8 @@ void BtRequestMessageTest::testDoReceivedAction_doesntHavePieceAndFastExtensionE
   msg->doReceivedAction();
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher_->messageQueue.size());
-  SharedHandle<MockBtMessage2> pieceMsg =
-    dynamic_pointer_cast<MockBtMessage2>(dispatcher_->messageQueue.front());
+  auto pieceMsg = std::dynamic_pointer_cast<MockBtMessage2>
+    (dispatcher_->messageQueue.front());
   CPPUNIT_ASSERT_EQUAL(std::string("reject"), pieceMsg->type);
   CPPUNIT_ASSERT_EQUAL((size_t)2, pieceMsg->index);
   CPPUNIT_ASSERT_EQUAL((uint32_t)16, pieceMsg->begin);
@@ -227,21 +227,21 @@ void BtRequestMessageTest::testDoReceivedAction_doesntHavePieceAndFastExtensionD
 }
 
 void BtRequestMessageTest::testHandleAbortRequestEvent() {
-  SharedHandle<Piece> piece(new Piece(1, 16*1024));
+  std::shared_ptr<Piece> piece(new Piece(1, 16*1024));
   CPPUNIT_ASSERT(!msg->isInvalidate());
   msg->onAbortOutstandingRequestEvent(BtAbortOutstandingRequestEvent(piece));
   CPPUNIT_ASSERT(msg->isInvalidate());
 }
 
 void BtRequestMessageTest::testHandleAbortRequestEvent_indexNoMatch() {
-  SharedHandle<Piece> piece(new Piece(2, 16*1024));
+  std::shared_ptr<Piece> piece(new Piece(2, 16*1024));
   CPPUNIT_ASSERT(!msg->isInvalidate());
   msg->onAbortOutstandingRequestEvent(BtAbortOutstandingRequestEvent(piece));
   CPPUNIT_ASSERT(!msg->isInvalidate());
 }
 
 void BtRequestMessageTest::testHandleAbortRequestEvent_alreadyInvalidated() {
-  SharedHandle<Piece> piece(new Piece(1, 16*1024));
+  std::shared_ptr<Piece> piece(new Piece(1, 16*1024));
   msg->setInvalidate(true);
   CPPUNIT_ASSERT(msg->isInvalidate());
   msg->onAbortOutstandingRequestEvent(BtAbortOutstandingRequestEvent(piece));
@@ -256,7 +256,7 @@ void BtRequestMessageTest::testToString() {
 void BtRequestMessageTest::testValidate() {
   BtRequestMessage msg(0, 0, 16*1024);
   msg.setBtMessageValidator
-    (SharedHandle<BtMessageValidator>
+    (std::shared_ptr<BtMessageValidator>
      (new RangeBtMessageValidator(&msg, 1024, 256*1024)));
   msg.validate();
 }
@@ -264,7 +264,7 @@ void BtRequestMessageTest::testValidate() {
 void BtRequestMessageTest::testValidate_lengthTooLong() {
   BtRequestMessage msg(0, 0, 16*1024+1);
   msg.setBtMessageValidator
-    (SharedHandle<BtMessageValidator>
+    (std::shared_ptr<BtMessageValidator>
      (new RangeBtMessageValidator(&msg, 1024, 256*1024)));
   try {
     msg.validate();
diff --git a/test/BtSuggestPieceMessageTest.cc b/test/BtSuggestPieceMessageTest.cc
index cad8cff2..4abf051a 100644
--- a/test/BtSuggestPieceMessageTest.cc
+++ b/test/BtSuggestPieceMessageTest.cc
@@ -32,7 +32,7 @@ void BtSuggestPieceMessageTest::testCreate() {
   unsigned char msg[9];
   bittorrent::createPeerMessageString(msg, sizeof(msg), 5, 13);
   bittorrent::setIntParam(&msg[5], 12345);
-  SharedHandle<BtSuggestPieceMessage> pm
+  std::shared_ptr<BtSuggestPieceMessage> pm
     (BtSuggestPieceMessage::create(&msg[4], 5));
   CPPUNIT_ASSERT_EQUAL((uint8_t)13, pm->getId());
   CPPUNIT_ASSERT_EQUAL((size_t)12345, pm->getIndex());
diff --git a/test/BtUnchokeMessageTest.cc b/test/BtUnchokeMessageTest.cc
index 17b7fe50..c8a92ac7 100644
--- a/test/BtUnchokeMessageTest.cc
+++ b/test/BtUnchokeMessageTest.cc
@@ -36,7 +36,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BtUnchokeMessageTest);
 void BtUnchokeMessageTest::testCreate() {
   unsigned char msg[5];
   bittorrent::createPeerMessageString(msg, sizeof(msg), 1, 1);
-  SharedHandle<BtUnchokeMessage> pm(BtUnchokeMessage::create(&msg[4], 1));
+  std::shared_ptr<BtUnchokeMessage> pm(BtUnchokeMessage::create(&msg[4], 1));
   CPPUNIT_ASSERT_EQUAL((uint8_t)1, pm->getId());
 
   // case: payload size is wrong
@@ -67,7 +67,7 @@ void BtUnchokeMessageTest::testCreateMessage() {
 }
 
 void BtUnchokeMessageTest::testDoReceivedAction() {
-  SharedHandle<Peer> peer(new Peer("host", 6969));
+  std::shared_ptr<Peer> peer(new Peer("host", 6969));
   peer->allocateSessionResource(1024, 1024*1024);
   peer->peerChoking(true);
   BtUnchokeMessage msg;
@@ -79,14 +79,14 @@ void BtUnchokeMessageTest::testDoReceivedAction() {
 }
 
 void BtUnchokeMessageTest::testOnSendComplete() {
-  SharedHandle<Peer> peer(new Peer("host", 6969));
+  std::shared_ptr<Peer> peer(new Peer("host", 6969));
   peer->allocateSessionResource(1024, 1024*1024);
   peer->amChoking(true);
   BtUnchokeMessage msg;
   msg.setPeer(peer);
 
   CPPUNIT_ASSERT(peer->amChoking());
-  SharedHandle<ProgressUpdate> pu(msg.getProgressUpdate());
+  std::shared_ptr<ProgressUpdate> pu(msg.getProgressUpdate());
   pu->update(0, true);
   CPPUNIT_ASSERT(!peer->amChoking());
 }
diff --git a/test/ChunkedDecodingStreamFilterTest.cc b/test/ChunkedDecodingStreamFilterTest.cc
index ae079272..06af8761 100644
--- a/test/ChunkedDecodingStreamFilterTest.cc
+++ b/test/ChunkedDecodingStreamFilterTest.cc
@@ -24,10 +24,10 @@ class ChunkedDecodingStreamFilterTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testGetName);
   CPPUNIT_TEST_SUITE_END();
 
-  SharedHandle<ChunkedDecodingStreamFilter> filter_;
-  SharedHandle<SinkStreamFilter> sinkFilter_;
-  SharedHandle<ByteArrayDiskWriter> writer_;
-  SharedHandle<Segment> segment_;
+  std::shared_ptr<ChunkedDecodingStreamFilter> filter_;
+  std::shared_ptr<SinkStreamFilter> sinkFilter_;
+  std::shared_ptr<ByteArrayDiskWriter> writer_;
+  std::shared_ptr<Segment> segment_;
 
   void clearWriter()
   {
diff --git a/test/DHTAnnouncePeerMessageTest.cc b/test/DHTAnnouncePeerMessageTest.cc
index 8cccda0f..750ed545 100644
--- a/test/DHTAnnouncePeerMessageTest.cc
+++ b/test/DHTAnnouncePeerMessageTest.cc
@@ -28,11 +28,11 @@ public:
   void testDoReceivedAction();
 
   class MockDHTMessageFactory2:public MockDHTMessageFactory {
-    virtual SharedHandle<DHTResponseMessage>
-    createAnnouncePeerReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+    virtual std::shared_ptr<DHTResponseMessage>
+    createAnnouncePeerReplyMessage(const std::shared_ptr<DHTNode>& remoteNode,
                                    const std::string& transactionID)
     {
-      return SharedHandle<DHTResponseMessage>
+      return std::shared_ptr<DHTResponseMessage>
         (new MockDHTResponseMessage
          (localNode_, remoteNode, "announce_peer", transactionID));
     }
@@ -44,8 +44,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTAnnouncePeerMessageTest);
 
 void DHTAnnouncePeerMessageTest::testGetBencodedMessage()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTNode> remoteNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode());
 
   unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
   util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
@@ -66,7 +66,7 @@ void DHTAnnouncePeerMessageTest::testGetBencodedMessage()
   dict.put("v", "A200");
   dict.put("y", "q");
   dict.put("q", "announce_peer");
-  SharedHandle<Dict> aDict = Dict::g();
+  std::shared_ptr<Dict> aDict = Dict::g();
   aDict->put("id", String::g(localNode->getID(), DHT_ID_LENGTH));
   aDict->put("info_hash", String::g(infoHash, DHT_ID_LENGTH));
   aDict->put("port", Integer::g(port));
@@ -79,8 +79,8 @@ void DHTAnnouncePeerMessageTest::testGetBencodedMessage()
 
 void DHTAnnouncePeerMessageTest::testDoReceivedAction()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTNode> remoteNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode());
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
 
@@ -107,18 +107,17 @@ void DHTAnnouncePeerMessageTest::testDoReceivedAction()
   msg.doReceivedAction();
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher.messageQueue_.size());
-  SharedHandle<MockDHTResponseMessage> m
-    (dynamic_pointer_cast<MockDHTResponseMessage>
-     (dispatcher.messageQueue_[0].message_));
+  auto m = std::dynamic_pointer_cast<MockDHTResponseMessage>
+    (dispatcher.messageQueue_[0].message_);
   CPPUNIT_ASSERT(*localNode == *m->getLocalNode());
   CPPUNIT_ASSERT(*remoteNode == *m->getRemoteNode());
   CPPUNIT_ASSERT_EQUAL(std::string("announce_peer"), m->getMessageType());
   CPPUNIT_ASSERT_EQUAL(transactionID, m->getTransactionID());
-  std::vector<SharedHandle<Peer> > peers;
+  std::vector<std::shared_ptr<Peer> > peers;
   peerAnnounceStorage.getPeers(peers, infoHash);
   CPPUNIT_ASSERT_EQUAL((size_t)1, peers.size());
   {
-    SharedHandle<Peer> peer = peers[0];
+    std::shared_ptr<Peer> peer = peers[0];
     CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), peer->getIPAddress());
     CPPUNIT_ASSERT_EQUAL((uint16_t)6882, peer->getPort());
   }
diff --git a/test/DHTAnnouncePeerReplyMessageTest.cc b/test/DHTAnnouncePeerReplyMessageTest.cc
index eb799c4f..16c049e7 100644
--- a/test/DHTAnnouncePeerReplyMessageTest.cc
+++ b/test/DHTAnnouncePeerReplyMessageTest.cc
@@ -27,8 +27,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTAnnouncePeerReplyMessageTest);
 
 void DHTAnnouncePeerReplyMessageTest::testGetBencodedMessage()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTNode> remoteNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode());
 
   unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
   util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
@@ -42,7 +42,7 @@ void DHTAnnouncePeerReplyMessageTest::testGetBencodedMessage()
   dict.put("t", transactionID);
   dict.put("v", "A200");
   dict.put("y", "r");
-  SharedHandle<Dict> rDict = Dict::g();
+  std::shared_ptr<Dict> rDict = Dict::g();
   rDict->put("id", String::g(localNode->getID(), DHT_ID_LENGTH));
   dict.put("r", rDict);
 
diff --git a/test/DHTBucketTest.cc b/test/DHTBucketTest.cc
index ff2b7cac..d45d2f2d 100644
--- a/test/DHTBucketTest.cc
+++ b/test/DHTBucketTest.cc
@@ -53,7 +53,7 @@ void DHTBucketTest::testGetRandomNodeID()
                                   0x00, 0x00, 0x00, 0x00, 0x00,
                                   0x00, 0x00, 0x00, 0x00, 0x00,
                                   0x00, 0x00, 0x00, 0x00, 0x00 };
-  SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
   {
     DHTBucket bucket(localNode);
     unsigned char nodeID[DHT_ID_LENGTH];
@@ -82,13 +82,13 @@ void DHTBucketTest::testIsInRange()
                                   0x00, 0x00, 0x00, 0x00, 0x00,
                                   0x00, 0x00, 0x00, 0x00, 0x00,
                                   0x00, 0x00, 0x00, 0x00, 0x00 };
-  SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+  std::shared_ptr<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 };
-    SharedHandle<DHTNode> node(new DHTNode(nodeID));
+    std::shared_ptr<DHTNode> node(new DHTNode(nodeID));
     DHTBucket bucket(localNode);
     CPPUNIT_ASSERT(bucket.isInRange(node));
     memset(nodeID, 0xff, sizeof(nodeID));
@@ -109,7 +109,7 @@ void DHTBucketTest::testIsInRange()
                                  0x00, 0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00, 0x00 };
-      SharedHandle<DHTNode> node(new DHTNode(nodeID));
+      std::shared_ptr<DHTNode> node(new DHTNode(nodeID));
       DHTBucket bucket(16, max, min, localNode);
       CPPUNIT_ASSERT(bucket.isInRange(node));
     }
@@ -119,7 +119,7 @@ void DHTBucketTest::testIsInRange()
                                  0xff, 0xff, 0xff, 0xff, 0xff,
                                  0xff, 0xff, 0xff, 0xff, 0xff,
                                  0xff, 0xff, 0xff, 0xff, 0xff };
-      SharedHandle<DHTNode> node(new DHTNode(nodeID));
+      std::shared_ptr<DHTNode> node(new DHTNode(nodeID));
       DHTBucket bucket(16, max, min, localNode);
       CPPUNIT_ASSERT(bucket.isInRange(node));
     }
@@ -128,7 +128,7 @@ void DHTBucketTest::testIsInRange()
                                  0x00, 0x00, 0x00, 0x00, 0x00,
                                  0xff, 0xff, 0xff, 0xff, 0xff,
                                  0xff, 0xff, 0xff, 0xff, 0xff };
-      SharedHandle<DHTNode> node(new DHTNode(nodeID));
+      std::shared_ptr<DHTNode> node(new DHTNode(nodeID));
       DHTBucket bucket(16, max, min, localNode);
       CPPUNIT_ASSERT(bucket.isInRange(node));
     }
@@ -138,7 +138,7 @@ void DHTBucketTest::testIsInRange()
                                  0x00, 0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00, 0x00 };
-      SharedHandle<DHTNode> node(new DHTNode(nodeID));
+      std::shared_ptr<DHTNode> node(new DHTNode(nodeID));
       DHTBucket bucket(16, max, min, localNode);
       CPPUNIT_ASSERT(!bucket.isInRange(node));
     }
@@ -148,7 +148,7 @@ void DHTBucketTest::testIsInRange()
                                  0xff, 0xff, 0xff, 0xff, 0xff,
                                  0xff, 0xff, 0xff, 0xff, 0xff,
                                  0xff, 0xff, 0xff, 0xff, 0xff };
-      SharedHandle<DHTNode> node(new DHTNode(nodeID));
+      std::shared_ptr<DHTNode> node(new DHTNode(nodeID));
       DHTBucket bucket(16, max, min, localNode);
       CPPUNIT_ASSERT(!bucket.isInRange(node));
     }
@@ -162,7 +162,7 @@ void DHTBucketTest::testSplitAllowed()
                                     0x00, 0x00, 0x00, 0x00, 0x00,
                                     0x00, 0x00, 0x00, 0x00, 0x00,
                                     0x00, 0x00, 0x00, 0x00, 0x00 };
-    SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+    std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
     DHTBucket bucket(localNode);
     CPPUNIT_ASSERT(bucket.splitAllowed());
   }
@@ -180,7 +180,7 @@ void DHTBucketTest::testSplitAllowed()
                                       0x00, 0x00, 0x00, 0x00, 0x00,
                                       0x00, 0x00, 0x00, 0x00, 0x00,
                                       0x00, 0x00, 0x00, 0x00, 0x00 };
-      SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+      std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
       DHTBucket bucket(3, max, min, localNode);
       CPPUNIT_ASSERT(!bucket.splitAllowed());
     }
@@ -189,7 +189,7 @@ void DHTBucketTest::testSplitAllowed()
                                       0x00, 0x00, 0x00, 0x00, 0x00,
                                       0x00, 0x00, 0x00, 0x00, 0x00,
                                       0x00, 0x00, 0x00, 0x00, 0x01 };
-      SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+      std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
       DHTBucket bucket(3, max, min, localNode);
       CPPUNIT_ASSERT(bucket.splitAllowed());
     }
@@ -201,10 +201,10 @@ void DHTBucketTest::testSplit()
   {
     unsigned char localNodeID[DHT_ID_LENGTH];
     memset(localNodeID, 0, DHT_ID_LENGTH);
-    SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+    std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
     {
       DHTBucket bucket(localNode);
-      SharedHandle<DHTBucket> r = bucket.split();
+      std::shared_ptr<DHTBucket> r = bucket.split();
       {
         unsigned char expectedRMax[] = { 0x7f, 0xff, 0xff, 0xff, 0xff,
                                          0xff, 0xff, 0xff, 0xff, 0xff,
@@ -233,10 +233,10 @@ void DHTBucketTest::testSplit()
       }
     }
     {
-      SharedHandle<DHTBucket> bucket(new DHTBucket(localNode));
+      std::shared_ptr<DHTBucket> bucket(new DHTBucket(localNode));
       for(int i = 0; i < 159; ++i) {
         CPPUNIT_ASSERT(bucket->splitAllowed());
-        SharedHandle<DHTBucket> t = bucket;
+        std::shared_ptr<DHTBucket> t = bucket;
         bucket = bucket->split();
         CPPUNIT_ASSERT(!t->splitAllowed());
       }
@@ -258,9 +258,9 @@ void DHTBucketTest::testSplit()
     unsigned char localNodeID[DHT_ID_LENGTH];
     memset(localNodeID, 0, DHT_ID_LENGTH);
     localNodeID[0] = 0x80;
-    SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+    std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
     DHTBucket bucket(localNode);
-    SharedHandle<DHTBucket> r = bucket.split();
+    std::shared_ptr<DHTBucket> r = bucket.split();
     {
       unsigned char expectedRMax[] = { 0x7f, 0xff, 0xff, 0xff, 0xff,
                                        0xff, 0xff, 0xff, 0xff, 0xff,
@@ -304,18 +304,18 @@ void DHTBucketTest::testAddNode()
 {
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0, DHT_ID_LENGTH);
-  SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
   DHTBucket bucket(localNode);
 
   unsigned char id[DHT_ID_LENGTH];
-  SharedHandle<DHTNode> nodes[8];
+  std::shared_ptr<DHTNode> nodes[8];
   for(size_t i = 0; i < DHTBucket::K; ++i) {
     createID(id, 0xf0, i);
     nodes[i].reset(new DHTNode(id));
     CPPUNIT_ASSERT(bucket.addNode(nodes[i]));
   }
   createID(id, 0xf0, 0xff);
-  SharedHandle<DHTNode> newNode(new DHTNode(id));
+  std::shared_ptr<DHTNode> newNode(new DHTNode(id));
   CPPUNIT_ASSERT(!bucket.addNode(newNode));
 
   // nodes[0] is located at the tail of the bucket(least recent seen)
@@ -328,11 +328,11 @@ void DHTBucketTest::testMoveToHead()
 {
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0, DHT_ID_LENGTH);
-  SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
   DHTBucket bucket(localNode);
 
   unsigned char id[DHT_ID_LENGTH];
-  SharedHandle<DHTNode> nodes[8];
+  std::shared_ptr<DHTNode> nodes[8];
   for(size_t i = 0; i < DHTBucket::K; ++i) {
     createID(id, 0xf0, i);
     nodes[i].reset(new DHTNode(id));
@@ -346,11 +346,11 @@ void DHTBucketTest::testMoveToTail()
 {
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0, DHT_ID_LENGTH);
-  SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
   DHTBucket bucket(localNode);
 
   unsigned char id[DHT_ID_LENGTH];
-  SharedHandle<DHTNode> nodes[8];
+  std::shared_ptr<DHTNode> nodes[8];
   for(size_t i = 0; i < DHTBucket::K; ++i) {
     createID(id, 0xf0, i);
     nodes[i].reset(new DHTNode(id));
@@ -364,11 +364,11 @@ void DHTBucketTest::testGetGoodNodes()
 {
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0, DHT_ID_LENGTH);
-  SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
   DHTBucket bucket(localNode);
 
   unsigned char id[DHT_ID_LENGTH];
-  SharedHandle<DHTNode> nodes[8];
+  std::shared_ptr<DHTNode> nodes[8];
   for(size_t i = 0; i < DHTBucket::K; ++i) {
     createID(id, 0xf0, i);
     nodes[i].reset(new DHTNode(id));
@@ -377,7 +377,7 @@ void DHTBucketTest::testGetGoodNodes()
   }
   nodes[3]->markBad();
   nodes[5]->markBad();
-  std::vector<SharedHandle<DHTNode> > goodNodes;
+  std::vector<std::shared_ptr<DHTNode> > goodNodes;
   bucket.getGoodNodes(goodNodes);
   CPPUNIT_ASSERT_EQUAL((size_t)6, goodNodes.size());
   CPPUNIT_ASSERT_EQUAL((uint16_t)6881, goodNodes[0]->getPort());
@@ -392,12 +392,12 @@ void DHTBucketTest::testCacheNode()
 {
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0, DHT_ID_LENGTH);
-  SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
   DHTBucket bucket(localNode);
 
-  SharedHandle<DHTNode> n1(new DHTNode());
-  SharedHandle<DHTNode> n2(new DHTNode());
-  SharedHandle<DHTNode> n3(new DHTNode());
+  std::shared_ptr<DHTNode> n1(new DHTNode());
+  std::shared_ptr<DHTNode> n2(new DHTNode());
+  std::shared_ptr<DHTNode> n3(new DHTNode());
 
   bucket.cacheNode(n1);
   bucket.cacheNode(n2);
@@ -414,11 +414,11 @@ void DHTBucketTest::testDropNode()
 {
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0, DHT_ID_LENGTH);
-  SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
   DHTBucket bucket(localNode);
 
   unsigned char id[DHT_ID_LENGTH];
-  SharedHandle<DHTNode> nodes[8];
+  std::shared_ptr<DHTNode> nodes[8];
   for(size_t i = 0; i < DHTBucket::K; ++i) {
     createID(id, 0xf0, i);
     nodes[i].reset(new DHTNode(id));
@@ -426,13 +426,13 @@ void DHTBucketTest::testDropNode()
     CPPUNIT_ASSERT(bucket.addNode(nodes[i]));
   }
 
-  SharedHandle<DHTNode> cachedNode1(new DHTNode());
-  SharedHandle<DHTNode> cachedNode2(new DHTNode());
+  std::shared_ptr<DHTNode> cachedNode1(new DHTNode());
+  std::shared_ptr<DHTNode> cachedNode2(new DHTNode());
 
   bucket.dropNode(nodes[3]);
   // nothing happens because the replacement cache is empty.
   {
-    std::deque<SharedHandle<DHTNode> > tnodes = bucket.getNodes();
+    std::deque<std::shared_ptr<DHTNode> > tnodes = bucket.getNodes();
     CPPUNIT_ASSERT_EQUAL((size_t)8, tnodes.size());
     CPPUNIT_ASSERT(*nodes[3] == *tnodes[3]);
   }
@@ -442,7 +442,7 @@ void DHTBucketTest::testDropNode()
 
   bucket.dropNode(nodes[3]);
   {
-    std::deque<SharedHandle<DHTNode> > tnodes = bucket.getNodes();
+    std::deque<std::shared_ptr<DHTNode> > tnodes = bucket.getNodes();
     CPPUNIT_ASSERT_EQUAL((size_t)8, tnodes.size());
     CPPUNIT_ASSERT(tnodes.end() ==
                    std::find_if(tnodes.begin(), tnodes.end(),
@@ -457,12 +457,12 @@ void DHTBucketTest::testGetNode()
 {
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0, DHT_ID_LENGTH);
-  SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
   DHTBucket bucket(localNode);
 
   unsigned char id[DHT_ID_LENGTH];
   createID(id, 0xf0, 0);
-  SharedHandle<DHTNode> node(new DHTNode(id));
+  std::shared_ptr<DHTNode> node(new DHTNode(id));
   node->setIPAddress("192.168.0.1");
   node->setPort(6881);
   CPPUNIT_ASSERT(bucket.addNode(node));
diff --git a/test/DHTBucketTreeTest.cc b/test/DHTBucketTreeTest.cc
index a5458344..f60b553f 100644
--- a/test/DHTBucketTreeTest.cc
+++ b/test/DHTBucketTreeTest.cc
@@ -33,11 +33,11 @@ void DHTBucketTreeTest::testDig()
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0xff, DHT_ID_LENGTH);
 
-  SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
 
-  SharedHandle<DHTBucket> bucket1(new DHTBucket(localNode));
-  SharedHandle<DHTBucket> bucket2 = bucket1->split();
-  SharedHandle<DHTBucket> bucket3 = bucket1->split();
+  std::shared_ptr<DHTBucket> bucket1(new DHTBucket(localNode));
+  std::shared_ptr<DHTBucket> bucket2 = bucket1->split();
+  std::shared_ptr<DHTBucket> bucket3 = bucket1->split();
   // Tree: number is prefix
   //
   //           +
@@ -65,13 +65,13 @@ void DHTBucketTreeTest::testFindBucketFor()
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0xaa, DHT_ID_LENGTH);
 
-  SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
 
-  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();
+  std::shared_ptr<DHTBucket> bucket1(new DHTBucket(localNode));
+  std::shared_ptr<DHTBucket> bucket2 = bucket1->split();
+  std::shared_ptr<DHTBucket> bucket3 = bucket1->split();
+  std::shared_ptr<DHTBucket> bucket4 = bucket3->split();
+  std::shared_ptr<DHTBucket> bucket5 = bucket3->split();
 
   {
     DHTBucketTreeNode b(bucket5);
@@ -112,13 +112,13 @@ void DHTBucketTreeTest::testFindClosestKNodes()
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0xaa, DHT_ID_LENGTH);
 
-  SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
 
-  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();
+  std::shared_ptr<DHTBucket> bucket1(new DHTBucket(localNode));
+  std::shared_ptr<DHTBucket> bucket2 = bucket1->split();
+  std::shared_ptr<DHTBucket> bucket3 = bucket1->split();
+  std::shared_ptr<DHTBucket> bucket4 = bucket3->split();
+  std::shared_ptr<DHTBucket> bucket5 = bucket3->split();
 
   unsigned char id[DHT_ID_LENGTH];
   {
@@ -135,20 +135,20 @@ void DHTBucketTreeTest::testFindClosestKNodes()
 
     for(size_t i = 0; i < 2; ++i) {
       bucket1->getRandomNodeID(id);
-      bucket1->addNode(SharedHandle<DHTNode>(new DHTNode(id)));
+      bucket1->addNode(std::shared_ptr<DHTNode>(new DHTNode(id)));
       bucket2->getRandomNodeID(id);
-      bucket2->addNode(SharedHandle<DHTNode>(new DHTNode(id)));
+      bucket2->addNode(std::shared_ptr<DHTNode>(new DHTNode(id)));
       bucket3->getRandomNodeID(id);
-      bucket3->addNode(SharedHandle<DHTNode>(new DHTNode(id)));
+      bucket3->addNode(std::shared_ptr<DHTNode>(new DHTNode(id)));
       bucket4->getRandomNodeID(id);
-      bucket4->addNode(SharedHandle<DHTNode>(new DHTNode(id)));
+      bucket4->addNode(std::shared_ptr<DHTNode>(new DHTNode(id)));
       bucket5->getRandomNodeID(id);
-      bucket5->addNode(SharedHandle<DHTNode>(new DHTNode(id)));
+      bucket5->addNode(std::shared_ptr<DHTNode>(new DHTNode(id)));
     }
     {
       unsigned char targetID[DHT_ID_LENGTH];
       memset(targetID, 0x80, DHT_ID_LENGTH);
-      std::vector<SharedHandle<DHTNode> > nodes;
+      std::vector<std::shared_ptr<DHTNode> > nodes;
       dht::findClosestKNodes(nodes, &bp4, targetID);
       CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size());
       CPPUNIT_ASSERT(bucket4->isInRange(nodes[0]));
@@ -163,7 +163,7 @@ void DHTBucketTreeTest::testFindClosestKNodes()
     {
       unsigned char targetID[DHT_ID_LENGTH];
       memset(targetID, 0xf0, DHT_ID_LENGTH);
-      std::vector<SharedHandle<DHTNode> > nodes;
+      std::vector<std::shared_ptr<DHTNode> > nodes;
       dht::findClosestKNodes(nodes, &bp4, targetID);
       CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size());
       CPPUNIT_ASSERT(bucket1->isInRange(nodes[0]));
@@ -178,11 +178,11 @@ void DHTBucketTreeTest::testFindClosestKNodes()
     {
       for(size_t i = 0; i < 6; ++i) {
         bucket4->getRandomNodeID(id);
-        bucket4->addNode(SharedHandle<DHTNode>(new DHTNode(id)));
+        bucket4->addNode(std::shared_ptr<DHTNode>(new DHTNode(id)));
       }
       unsigned char targetID[DHT_ID_LENGTH];
       memset(targetID, 0x80, DHT_ID_LENGTH);
-      std::vector<SharedHandle<DHTNode> > nodes;
+      std::vector<std::shared_ptr<DHTNode> > nodes;
       dht::findClosestKNodes(nodes, &bp4, targetID);
       CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size());
       for(size_t i = 0; i < DHTBucket::K; ++i) {
@@ -198,17 +198,17 @@ void DHTBucketTreeTest::testEnumerateBucket()
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0xaa, DHT_ID_LENGTH);
 
-  SharedHandle<DHTNode> localNode(new DHTNode(localNodeID));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(localNodeID));
 
-  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();
+  std::shared_ptr<DHTBucket> bucket1(new DHTBucket(localNode));
+  std::shared_ptr<DHTBucket> bucket2 = bucket1->split();
+  std::shared_ptr<DHTBucket> bucket3 = bucket1->split();
+  std::shared_ptr<DHTBucket> bucket4 = bucket3->split();
+  std::shared_ptr<DHTBucket> bucket5 = bucket3->split();
 
   {
     DHTBucketTreeNode b(bucket1);
-    std::vector<SharedHandle<DHTBucket> > buckets;
+    std::vector<std::shared_ptr<DHTBucket> > buckets;
     dht::enumerateBucket(buckets, &b);
     CPPUNIT_ASSERT_EQUAL((size_t)1, buckets.size());
     CPPUNIT_ASSERT(*bucket1 == *buckets[0]);
@@ -225,7 +225,7 @@ void DHTBucketTreeTest::testEnumerateBucket()
     DHTBucketTreeNode* bp3 = new DHTBucketTreeNode(bp2, b1);
     DHTBucketTreeNode bp4(b2, bp3);
 
-    std::vector<SharedHandle<DHTBucket> > buckets;
+    std::vector<std::shared_ptr<DHTBucket> > buckets;
     dht::enumerateBucket(buckets, &bp4);
     CPPUNIT_ASSERT_EQUAL((size_t)5, buckets.size());
     CPPUNIT_ASSERT(*bucket2 == *buckets[0]);
diff --git a/test/DHTFindNodeMessageTest.cc b/test/DHTFindNodeMessageTest.cc
index 3283e677..401cf270 100644
--- a/test/DHTFindNodeMessageTest.cc
+++ b/test/DHTFindNodeMessageTest.cc
@@ -29,13 +29,13 @@ public:
 
   class MockDHTMessageFactory2:public MockDHTMessageFactory {
   public:
-    virtual SharedHandle<DHTResponseMessage>
+    virtual std::shared_ptr<DHTResponseMessage>
     createFindNodeReplyMessage
-    (const SharedHandle<DHTNode>& remoteNode,
-     const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+    (const std::shared_ptr<DHTNode>& remoteNode,
+     const std::vector<std::shared_ptr<DHTNode> >& closestKNodes,
      const std::string& transactionID)
     {
-      SharedHandle<MockDHTResponseMessage> m
+      std::shared_ptr<MockDHTResponseMessage> m
         (new MockDHTResponseMessage
          (localNode_, remoteNode, "find_node", transactionID));
       m->nodes_ = closestKNodes;
@@ -49,14 +49,14 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTFindNodeMessageTest);
 
 void DHTFindNodeMessageTest::testGetBencodedMessage()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTNode> remoteNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode());
 
   unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
   util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
   std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
 
-  SharedHandle<DHTNode> targetNode(new DHTNode());
+  std::shared_ptr<DHTNode> targetNode(new DHTNode());
 
   DHTFindNodeMessage msg(localNode, remoteNode, targetNode->getID(), transactionID);
   msg.setVersion("A200");
@@ -67,7 +67,7 @@ void DHTFindNodeMessageTest::testGetBencodedMessage()
   dict.put("v", "A200");
   dict.put("y", "q");
   dict.put("q", "find_node");
-  SharedHandle<Dict> aDict = Dict::g();
+  std::shared_ptr<Dict> aDict = Dict::g();
   aDict->put("id", String::g(localNode->getID(), DHT_ID_LENGTH));
   aDict->put("target", String::g(targetNode->getID(), DHT_ID_LENGTH));
   dict.put("a", aDict);
@@ -77,14 +77,14 @@ void DHTFindNodeMessageTest::testGetBencodedMessage()
 
 void DHTFindNodeMessageTest::testDoReceivedAction()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTNode> remoteNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode());
 
   unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
   util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
   std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
 
-  SharedHandle<DHTNode> targetNode(new DHTNode());
+  std::shared_ptr<DHTNode> targetNode(new DHTNode());
 
   MockDHTMessageDispatcher dispatcher;
   MockDHTMessageFactory2 factory;
@@ -100,9 +100,8 @@ void DHTFindNodeMessageTest::testDoReceivedAction()
   msg.doReceivedAction();
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher.messageQueue_.size());
-  SharedHandle<MockDHTResponseMessage> m
-    (dynamic_pointer_cast<MockDHTResponseMessage>
-     (dispatcher.messageQueue_[0].message_));
+  auto m = std::dynamic_pointer_cast<MockDHTResponseMessage>
+    (dispatcher.messageQueue_[0].message_);
   CPPUNIT_ASSERT(*localNode == *m->getLocalNode());
   CPPUNIT_ASSERT(*remoteNode == *m->getRemoteNode());
   CPPUNIT_ASSERT_EQUAL(std::string("find_node"), m->getMessageType());
diff --git a/test/DHTFindNodeReplyMessageTest.cc b/test/DHTFindNodeReplyMessageTest.cc
index 7a15b445..cdb715c9 100644
--- a/test/DHTFindNodeReplyMessageTest.cc
+++ b/test/DHTFindNodeReplyMessageTest.cc
@@ -32,8 +32,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTFindNodeReplyMessageTest);
 
 void DHTFindNodeReplyMessageTest::testGetBencodedMessage()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTNode> remoteNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode());
 
   unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
   util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
@@ -42,7 +42,7 @@ void DHTFindNodeReplyMessageTest::testGetBencodedMessage()
   DHTFindNodeReplyMessage msg(AF_INET, localNode, remoteNode, transactionID);
   msg.setVersion("A200");
   std::string compactNodeInfo;
-  SharedHandle<DHTNode> nodes[8];
+  std::shared_ptr<DHTNode> nodes[8];
   for(size_t i = 0; i < DHTBucket::K; ++i) {
     nodes[i].reset(new DHTNode());
     nodes[i]->setIPAddress("192.168.0."+util::uitos(i+1));
@@ -56,7 +56,7 @@ void DHTFindNodeReplyMessageTest::testGetBencodedMessage()
       std::string(&buf[0], &buf[COMPACT_LEN_IPV4]);
   }
   msg.setClosestKNodes
-    (std::vector<SharedHandle<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
+    (std::vector<std::shared_ptr<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
 
   std::string msgbody = msg.getBencodedMessage();
 
@@ -64,7 +64,7 @@ void DHTFindNodeReplyMessageTest::testGetBencodedMessage()
   dict.put("t", transactionID);
   dict.put("v", "A200");
   dict.put("y", "r");
-  SharedHandle<Dict> rDict = Dict::g();
+  std::shared_ptr<Dict> rDict = Dict::g();
   rDict->put("id", String::g(localNode->getID(), DHT_ID_LENGTH));
   rDict->put("nodes", compactNodeInfo);
   dict.put("r", rDict);
@@ -74,8 +74,8 @@ void DHTFindNodeReplyMessageTest::testGetBencodedMessage()
 
 void DHTFindNodeReplyMessageTest::testGetBencodedMessage6()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTNode> remoteNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode());
 
   unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
   util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
@@ -84,7 +84,7 @@ void DHTFindNodeReplyMessageTest::testGetBencodedMessage6()
   DHTFindNodeReplyMessage msg(AF_INET6, localNode, remoteNode, transactionID);
   msg.setVersion("A200");
   std::string compactNodeInfo;
-  SharedHandle<DHTNode> nodes[8];
+  std::shared_ptr<DHTNode> nodes[8];
   for(size_t i = 0; i < DHTBucket::K; ++i) {
     nodes[i].reset(new DHTNode());
     nodes[i]->setIPAddress("2001::000"+util::uitos(i+1));
@@ -98,7 +98,7 @@ void DHTFindNodeReplyMessageTest::testGetBencodedMessage6()
       std::string(&buf[0], &buf[COMPACT_LEN_IPV6]);
   }
   msg.setClosestKNodes
-    (std::vector<SharedHandle<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
+    (std::vector<std::shared_ptr<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
 
   std::string msgbody = msg.getBencodedMessage();
 
@@ -106,7 +106,7 @@ void DHTFindNodeReplyMessageTest::testGetBencodedMessage6()
   dict.put("t", transactionID);
   dict.put("v", "A200");
   dict.put("y", "r");
-  SharedHandle<Dict> rDict = Dict::g();
+  std::shared_ptr<Dict> rDict = Dict::g();
   rDict->put("id", String::g(localNode->getID(), DHT_ID_LENGTH));
   rDict->put("nodes6", compactNodeInfo);
   dict.put("r", rDict);
diff --git a/test/DHTGetPeersMessageTest.cc b/test/DHTGetPeersMessageTest.cc
index 0343a4c3..0471cbc5 100644
--- a/test/DHTGetPeersMessageTest.cc
+++ b/test/DHTGetPeersMessageTest.cc
@@ -31,15 +31,15 @@ public:
 
   class MockDHTMessageFactory2:public MockDHTMessageFactory {
   public:
-    virtual SharedHandle<DHTResponseMessage>
+    virtual std::shared_ptr<DHTResponseMessage>
     createGetPeersReplyMessage
-    (const SharedHandle<DHTNode>& remoteNode,
-     const std::vector<SharedHandle<DHTNode> >& closestKNodes,
-     const std::vector<SharedHandle<Peer> >& peers,
+    (const std::shared_ptr<DHTNode>& remoteNode,
+     const std::vector<std::shared_ptr<DHTNode> >& closestKNodes,
+     const std::vector<std::shared_ptr<Peer> >& peers,
      const std::string& token,
      const std::string& transactionID)
     {
-      SharedHandle<MockDHTResponseMessage> m
+      std::shared_ptr<MockDHTResponseMessage> m
         (new MockDHTResponseMessage
          (localNode_, remoteNode, "get_peers", transactionID));
       m->nodes_ = closestKNodes;
@@ -55,8 +55,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTGetPeersMessageTest);
 
 void DHTGetPeersMessageTest::testGetBencodedMessage()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTNode> remoteNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode());
 
   unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
   util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
@@ -75,7 +75,7 @@ void DHTGetPeersMessageTest::testGetBencodedMessage()
   dict.put("v", "A200");
   dict.put("y", "q");
   dict.put("q", "get_peers");
-  SharedHandle<Dict> aDict = Dict::g();
+  std::shared_ptr<Dict> aDict = Dict::g();
   aDict->put("id", String::g(localNode->getID(), DHT_ID_LENGTH));
   aDict->put("info_hash", String::g(infoHash, DHT_ID_LENGTH));
   dict.put("a", aDict);
@@ -86,8 +86,8 @@ void DHTGetPeersMessageTest::testGetBencodedMessage()
 
 void DHTGetPeersMessageTest::testDoReceivedAction()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTNode> remoteNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode());
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
 
@@ -120,9 +120,8 @@ void DHTGetPeersMessageTest::testDoReceivedAction()
     msg.doReceivedAction();
 
     CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher.messageQueue_.size());
-    SharedHandle<MockDHTResponseMessage> m
-      (dynamic_pointer_cast<MockDHTResponseMessage>
-       (dispatcher.messageQueue_[0].message_));
+    auto m = std::dynamic_pointer_cast<MockDHTResponseMessage>
+      (dispatcher.messageQueue_[0].message_);
     CPPUNIT_ASSERT(*localNode == *m->getLocalNode());
     CPPUNIT_ASSERT(*remoteNode == *m->getRemoteNode());
     CPPUNIT_ASSERT_EQUAL(std::string("get_peers"), m->getMessageType());
@@ -131,12 +130,12 @@ void DHTGetPeersMessageTest::testDoReceivedAction()
     CPPUNIT_ASSERT_EQUAL((size_t)0, m->nodes_.size());
     CPPUNIT_ASSERT_EQUAL((size_t)2, m->peers_.size());
     {
-      SharedHandle<Peer> peer = m->peers_[0];
+      std::shared_ptr<Peer> peer = m->peers_[0];
       CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.100"), peer->getIPAddress());
       CPPUNIT_ASSERT_EQUAL((uint16_t)6888, peer->getPort());
     }
     {
-      SharedHandle<Peer> peer = m->peers_[1];
+      std::shared_ptr<Peer> peer = m->peers_[1];
       CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.101"), peer->getIPAddress());
       CPPUNIT_ASSERT_EQUAL((uint16_t)6889, peer->getPort());
     }
@@ -146,7 +145,7 @@ void DHTGetPeersMessageTest::testDoReceivedAction()
     // localhost doesn't have peer contact information for that infohash.
     DHTPeerAnnounceStorage peerAnnounceStorage;
     DHTRoutingTable routingTable(localNode);
-    SharedHandle<DHTNode> returnNode1(new DHTNode());
+    std::shared_ptr<DHTNode> returnNode1(new DHTNode());
     routingTable.addNode(returnNode1);
 
     msg.setPeerAnnounceStorage(&peerAnnounceStorage);
@@ -155,9 +154,8 @@ void DHTGetPeersMessageTest::testDoReceivedAction()
     msg.doReceivedAction();
 
     CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher.messageQueue_.size());
-    SharedHandle<MockDHTResponseMessage> m
-      (dynamic_pointer_cast<MockDHTResponseMessage>
-       (dispatcher.messageQueue_[0].message_));
+    auto m = std::dynamic_pointer_cast<MockDHTResponseMessage>
+      (dispatcher.messageQueue_[0].message_);
     CPPUNIT_ASSERT(*localNode == *m->getLocalNode());
     CPPUNIT_ASSERT(*remoteNode == *m->getRemoteNode());
     CPPUNIT_ASSERT_EQUAL(std::string("get_peers"), m->getMessageType());
diff --git a/test/DHTGetPeersReplyMessageTest.cc b/test/DHTGetPeersReplyMessageTest.cc
index 784159ba..ebafbbe6 100644
--- a/test/DHTGetPeersReplyMessageTest.cc
+++ b/test/DHTGetPeersReplyMessageTest.cc
@@ -33,8 +33,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTGetPeersReplyMessageTest);
 
 void DHTGetPeersReplyMessageTest::testGetBencodedMessage()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTNode> remoteNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode());
 
   unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
   util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
@@ -49,13 +49,13 @@ void DHTGetPeersReplyMessageTest::testGetBencodedMessage()
   dict.put("t", transactionID);
   dict.put("v", "A200");
   dict.put("y", "r");
-  SharedHandle<Dict> rDict = Dict::g();
+  std::shared_ptr<Dict> rDict = Dict::g();
   rDict->put("id", String::g(localNode->getID(), DHT_ID_LENGTH));
   rDict->put("token", token);
   dict.put("r", rDict);
   {
     std::string compactNodeInfo;
-    SharedHandle<DHTNode> nodes[8];
+    std::shared_ptr<DHTNode> nodes[8];
     for(size_t i = 0; i < DHTBucket::K; ++i) {
       nodes[i].reset(new DHTNode());
       nodes[i]->setIPAddress("192.168.0."+util::uitos(i+1));
@@ -71,13 +71,13 @@ void DHTGetPeersReplyMessageTest::testGetBencodedMessage()
         std::string(&buf[0], &buf[COMPACT_LEN_IPV4]);
     }
     msg.setClosestKNodes
-      (std::vector<SharedHandle<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
+      (std::vector<std::shared_ptr<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
     rDict->put("nodes", compactNodeInfo);
 
-    std::vector<SharedHandle<Peer> > peers;
-    SharedHandle<List> valuesList = List::g();
+    std::vector<std::shared_ptr<Peer> > peers;
+    std::shared_ptr<List> valuesList = List::g();
     for(size_t i = 0; i < 4; ++i) {
-      SharedHandle<Peer> peer(new Peer("192.168.0."+util::uitos(i+1), 6881+i));
+      std::shared_ptr<Peer> peer(new Peer("192.168.0."+util::uitos(i+1), 6881+i));
       unsigned char buffer[COMPACT_LEN_IPV6];
       CPPUNIT_ASSERT_EQUAL
         (COMPACT_LEN_IPV4,
@@ -97,8 +97,8 @@ void DHTGetPeersReplyMessageTest::testGetBencodedMessage()
 
 void DHTGetPeersReplyMessageTest::testGetBencodedMessage6()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTNode> remoteNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode());
 
   unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
   util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
@@ -113,13 +113,13 @@ void DHTGetPeersReplyMessageTest::testGetBencodedMessage6()
   dict.put("t", transactionID);
   dict.put("v", "A200");
   dict.put("y", "r");
-  SharedHandle<Dict> rDict = Dict::g();
+  std::shared_ptr<Dict> rDict = Dict::g();
   rDict->put("id", String::g(localNode->getID(), DHT_ID_LENGTH));
   rDict->put("token", token);
   dict.put("r", rDict);
   {
     std::string compactNodeInfo;
-    SharedHandle<DHTNode> nodes[8];
+    std::shared_ptr<DHTNode> nodes[8];
     for(size_t i = 0; i < DHTBucket::K; ++i) {
       nodes[i].reset(new DHTNode());
       nodes[i]->setIPAddress("2001::000"+util::uitos(i+1));
@@ -134,13 +134,13 @@ void DHTGetPeersReplyMessageTest::testGetBencodedMessage6()
         std::string(&buf[0], &buf[COMPACT_LEN_IPV6]);
     }
     msg.setClosestKNodes
-      (std::vector<SharedHandle<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
+      (std::vector<std::shared_ptr<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
     rDict->put("nodes6", compactNodeInfo);
 
-    std::vector<SharedHandle<Peer> > peers;
-    SharedHandle<List> valuesList = List::g();
+    std::vector<std::shared_ptr<Peer> > peers;
+    std::shared_ptr<List> valuesList = List::g();
     for(size_t i = 0; i < 4; ++i) {
-      SharedHandle<Peer> peer(new Peer("2001::100"+util::uitos(i+1), 6881+i));
+      std::shared_ptr<Peer> peer(new Peer("2001::100"+util::uitos(i+1), 6881+i));
       unsigned char buffer[COMPACT_LEN_IPV6];
       CPPUNIT_ASSERT_EQUAL
         (COMPACT_LEN_IPV6,
diff --git a/test/DHTIDCloserTest.cc b/test/DHTIDCloserTest.cc
index a5e3a944..356fce9f 100644
--- a/test/DHTIDCloserTest.cc
+++ b/test/DHTIDCloserTest.cc
@@ -30,26 +30,26 @@ void DHTIDCloserTest::testOperator()
   unsigned char id[DHT_ID_LENGTH];
   memset(id, 0xf0, DHT_ID_LENGTH);
 
-  SharedHandle<DHTNodeLookupEntry> e1
-    (new DHTNodeLookupEntry(SharedHandle<DHTNode>(new DHTNode(id))));
+  std::shared_ptr<DHTNodeLookupEntry> e1
+    (new DHTNodeLookupEntry(std::shared_ptr<DHTNode>(new DHTNode(id))));
 
   id[0] = 0xb0;
-  SharedHandle<DHTNodeLookupEntry> e2
-    (new DHTNodeLookupEntry(SharedHandle<DHTNode>(new DHTNode(id))));
+  std::shared_ptr<DHTNodeLookupEntry> e2
+    (new DHTNodeLookupEntry(std::shared_ptr<DHTNode>(new DHTNode(id))));
 
   id[0] = 0xa0;
-  SharedHandle<DHTNodeLookupEntry> e3
-    (new DHTNodeLookupEntry(SharedHandle<DHTNode>(new DHTNode(id))));
+  std::shared_ptr<DHTNodeLookupEntry> e3
+    (new DHTNodeLookupEntry(std::shared_ptr<DHTNode>(new DHTNode(id))));
 
   id[0] = 0x80;
-  SharedHandle<DHTNodeLookupEntry> e4
-    (new DHTNodeLookupEntry(SharedHandle<DHTNode>(new DHTNode(id))));
+  std::shared_ptr<DHTNodeLookupEntry> e4
+    (new DHTNodeLookupEntry(std::shared_ptr<DHTNode>(new DHTNode(id))));
 
   id[0] = 0x00;
-  SharedHandle<DHTNodeLookupEntry> e5
-    (new DHTNodeLookupEntry(SharedHandle<DHTNode>(new DHTNode(id))));
+  std::shared_ptr<DHTNodeLookupEntry> e5
+    (new DHTNodeLookupEntry(std::shared_ptr<DHTNode>(new DHTNode(id))));
 
-  std::deque<SharedHandle<DHTNodeLookupEntry> > entries;
+  std::deque<std::shared_ptr<DHTNodeLookupEntry> > entries;
   entries.push_back(e1);
   entries.push_back(e2);
   entries.push_back(e3);
diff --git a/test/DHTMessageFactoryImplTest.cc b/test/DHTMessageFactoryImplTest.cc
index 67590297..6ee7087b 100644
--- a/test/DHTMessageFactoryImplTest.cc
+++ b/test/DHTMessageFactoryImplTest.cc
@@ -40,11 +40,11 @@ class DHTMessageFactoryImplTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testReceivedErrorMessage);
   CPPUNIT_TEST_SUITE_END();
 public:
-  SharedHandle<DHTMessageFactoryImpl> factory;
+  std::shared_ptr<DHTMessageFactoryImpl> factory;
 
-  SharedHandle<DHTRoutingTable> routingTable;
+  std::shared_ptr<DHTRoutingTable> routingTable;
 
-  SharedHandle<DHTNode> localNode;
+  std::shared_ptr<DHTNode> localNode;
 
   unsigned char transactionID[DHT_TRANSACTION_ID_LENGTH];
 
@@ -85,14 +85,13 @@ void DHTMessageFactoryImplTest::testCreatePingMessage()
   dict.put("t", String::g(transactionID, DHT_TRANSACTION_ID_LENGTH));
   dict.put("y", "q");
   dict.put("q", "ping");
-  SharedHandle<Dict> aDict = Dict::g();
+  std::shared_ptr<Dict> aDict = Dict::g();
   aDict->put("id", String::g(remoteNodeID, DHT_ID_LENGTH));
   dict.put("a", aDict);
 
-  SharedHandle<DHTPingMessage> m
-    (dynamic_pointer_cast<DHTPingMessage>
-     (factory->createQueryMessage(&dict, "192.168.0.1", 6881)));
-  SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
+  auto m = std::dynamic_pointer_cast<DHTPingMessage>
+    (factory->createQueryMessage(&dict, "192.168.0.1", 6881));
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode(remoteNodeID));
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
 
@@ -107,19 +106,18 @@ void DHTMessageFactoryImplTest::testCreatePingReplyMessage()
   Dict dict;
   dict.put("t", String::g(transactionID, DHT_TRANSACTION_ID_LENGTH));
   dict.put("y", "r");
-  SharedHandle<Dict> rDict = Dict::g();
+  std::shared_ptr<Dict> rDict = Dict::g();
   rDict->put("id", String::g(remoteNodeID, DHT_ID_LENGTH));
   dict.put("r", rDict);
 
-  SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode(remoteNodeID));
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
 
-  SharedHandle<DHTPingReplyMessage> m
-    (dynamic_pointer_cast<DHTPingReplyMessage>
-     (factory->createResponseMessage("ping", &dict,
-                                     remoteNode->getIPAddress(),
-                                     remoteNode->getPort())));
+  auto m = std::dynamic_pointer_cast<DHTPingReplyMessage>
+    (factory->createResponseMessage("ping", &dict,
+                                    remoteNode->getIPAddress(),
+                                    remoteNode->getPort()));
 
   CPPUNIT_ASSERT(*localNode == *m->getLocalNode());
   CPPUNIT_ASSERT(*remoteNode == *m->getRemoteNode());
@@ -133,17 +131,16 @@ void DHTMessageFactoryImplTest::testCreateFindNodeMessage()
   dict.put("t", String::g(transactionID, DHT_TRANSACTION_ID_LENGTH));
   dict.put("y", "q");
   dict.put("q", "find_node");
-  SharedHandle<Dict> aDict = Dict::g();
+  std::shared_ptr<Dict> aDict = Dict::g();
   aDict->put("id", String::g(remoteNodeID, DHT_ID_LENGTH));
   unsigned char targetNodeID[DHT_ID_LENGTH];
   memset(targetNodeID, 0x11, DHT_ID_LENGTH);
   aDict->put("target", String::g(targetNodeID, DHT_ID_LENGTH));
   dict.put("a", aDict);
 
-  SharedHandle<DHTFindNodeMessage> m
-    (dynamic_pointer_cast<DHTFindNodeMessage>
-     (factory->createQueryMessage(&dict, "192.168.0.1", 6881)));
-  SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
+  auto m = std::dynamic_pointer_cast<DHTFindNodeMessage>
+    (factory->createQueryMessage(&dict, "192.168.0.1", 6881));
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode(remoteNodeID));
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
 
@@ -161,10 +158,10 @@ void DHTMessageFactoryImplTest::testCreateFindNodeReplyMessage()
     Dict dict;
     dict.put("t", String::g(transactionID, DHT_TRANSACTION_ID_LENGTH));
     dict.put("y", "r");
-    SharedHandle<Dict> rDict = Dict::g();
+    std::shared_ptr<Dict> rDict = Dict::g();
     rDict->put("id", String::g(remoteNodeID, DHT_ID_LENGTH));
     std::string compactNodeInfo;
-    SharedHandle<DHTNode> nodes[8];
+    std::shared_ptr<DHTNode> nodes[8];
     for(size_t i = 0; i < DHTBucket::K; ++i) {
       nodes[i].reset(new DHTNode());
       nodes[i]->setIPAddress("192.168.0."+util::uitos(i+1));
@@ -182,15 +179,14 @@ void DHTMessageFactoryImplTest::testCreateFindNodeReplyMessage()
     rDict->put("nodes", compactNodeInfo);
     dict.put("r", rDict);
 
-    SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
+    std::shared_ptr<DHTNode> remoteNode(new DHTNode(remoteNodeID));
     remoteNode->setIPAddress("192.168.0.1");
     remoteNode->setPort(6881);
 
-    SharedHandle<DHTFindNodeReplyMessage> m
-      (dynamic_pointer_cast<DHTFindNodeReplyMessage>
-       (factory->createResponseMessage("find_node", &dict,
-                                       remoteNode->getIPAddress(),
-                                       remoteNode->getPort())));
+    auto m = std::dynamic_pointer_cast<DHTFindNodeReplyMessage>
+      (factory->createResponseMessage("find_node", &dict,
+                                      remoteNode->getIPAddress(),
+                                      remoteNode->getPort()));
 
     CPPUNIT_ASSERT(*localNode == *m->getLocalNode());
     CPPUNIT_ASSERT(*remoteNode == *m->getRemoteNode());
@@ -213,10 +209,10 @@ void DHTMessageFactoryImplTest::testCreateFindNodeReplyMessage6()
     Dict dict;
     dict.put("t", String::g(transactionID, DHT_TRANSACTION_ID_LENGTH));
     dict.put("y", "r");
-    SharedHandle<Dict> rDict = Dict::g();
+    std::shared_ptr<Dict> rDict = Dict::g();
     rDict->put("id", String::g(remoteNodeID, DHT_ID_LENGTH));
     std::string compactNodeInfo;
-    SharedHandle<DHTNode> nodes[8];
+    std::shared_ptr<DHTNode> nodes[8];
     for(size_t i = 0; i < DHTBucket::K; ++i) {
       nodes[i].reset(new DHTNode());
       nodes[i]->setIPAddress("2001::000"+util::uitos(i+1));
@@ -234,15 +230,14 @@ void DHTMessageFactoryImplTest::testCreateFindNodeReplyMessage6()
     rDict->put("nodes6", compactNodeInfo);
     dict.put("r", rDict);
 
-    SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
+    std::shared_ptr<DHTNode> remoteNode(new DHTNode(remoteNodeID));
     remoteNode->setIPAddress("2001::2001");
     remoteNode->setPort(6881);
 
-    SharedHandle<DHTFindNodeReplyMessage> m
-      (dynamic_pointer_cast<DHTFindNodeReplyMessage>
-       (factory->createResponseMessage("find_node", &dict,
-                                       remoteNode->getIPAddress(),
-                                       remoteNode->getPort())));
+    auto m = std::dynamic_pointer_cast<DHTFindNodeReplyMessage>
+      (factory->createResponseMessage("find_node", &dict,
+                                      remoteNode->getIPAddress(),
+                                      remoteNode->getPort()));
 
     CPPUNIT_ASSERT(*localNode == *m->getLocalNode());
     CPPUNIT_ASSERT(*remoteNode == *m->getRemoteNode());
@@ -262,17 +257,16 @@ void DHTMessageFactoryImplTest::testCreateGetPeersMessage()
   dict.put("t", String::g(transactionID, DHT_TRANSACTION_ID_LENGTH));
   dict.put("y", "q");
   dict.put("q", "get_peers");
-  SharedHandle<Dict> aDict = Dict::g();
+  std::shared_ptr<Dict> aDict = Dict::g();
   aDict->put("id", String::g(remoteNodeID, DHT_ID_LENGTH));
   unsigned char infoHash[DHT_ID_LENGTH];
   memset(infoHash, 0x11, DHT_ID_LENGTH);
   aDict->put("info_hash", String::g(infoHash, DHT_ID_LENGTH));
   dict.put("a", aDict);
 
-  SharedHandle<DHTGetPeersMessage> m
-    (dynamic_pointer_cast<DHTGetPeersMessage>
-     (factory->createQueryMessage(&dict, "192.168.0.1", 6881)));
-  SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
+  auto m = std::dynamic_pointer_cast<DHTGetPeersMessage>
+    (factory->createQueryMessage(&dict, "192.168.0.1", 6881));
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode(remoteNodeID));
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
 
@@ -290,10 +284,10 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage()
     Dict dict;
     dict.put("t", String::g(transactionID, DHT_TRANSACTION_ID_LENGTH));
     dict.put("y", "r");
-    SharedHandle<Dict> rDict = Dict::g();
+    std::shared_ptr<Dict> rDict = Dict::g();
     rDict->put("id", String::g(remoteNodeID, DHT_ID_LENGTH));
     std::string compactNodeInfo;
-    SharedHandle<DHTNode> nodes[8];
+    std::shared_ptr<DHTNode> nodes[8];
     for(size_t i = 0; i < DHTBucket::K; ++i) {
       nodes[i].reset(new DHTNode());
       nodes[i]->setIPAddress("192.168.0."+util::uitos(i+1));
@@ -310,10 +304,10 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage()
     }
     rDict->put("nodes", compactNodeInfo);
 
-    std::deque<SharedHandle<Peer> > peers;
-    SharedHandle<List> valuesList = List::g();
+    std::deque<std::shared_ptr<Peer> > peers;
+    std::shared_ptr<List> valuesList = List::g();
     for(size_t i = 0; i < 4; ++i) {
-      SharedHandle<Peer> peer(new Peer("192.168.0."+util::uitos(i+1), 6881+i));
+      std::shared_ptr<Peer> peer(new Peer("192.168.0."+util::uitos(i+1), 6881+i));
       unsigned char buffer[COMPACT_LEN_IPV6];
       CPPUNIT_ASSERT_EQUAL
         (COMPACT_LEN_IPV4,
@@ -327,15 +321,14 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage()
     rDict->put("token", "token");
     dict.put("r", rDict);
 
-    SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
+    std::shared_ptr<DHTNode> remoteNode(new DHTNode(remoteNodeID));
     remoteNode->setIPAddress("192.168.0.1");
     remoteNode->setPort(6881);
 
-    SharedHandle<DHTGetPeersReplyMessage> m
-      (dynamic_pointer_cast<DHTGetPeersReplyMessage>
-       (factory->createResponseMessage("get_peers", &dict,
-                                       remoteNode->getIPAddress(),
-                                       remoteNode->getPort())));
+    auto m = std::dynamic_pointer_cast<DHTGetPeersReplyMessage>
+      (factory->createResponseMessage("get_peers", &dict,
+                                      remoteNode->getIPAddress(),
+                                      remoteNode->getPort()));
 
     CPPUNIT_ASSERT(*localNode == *m->getLocalNode());
     CPPUNIT_ASSERT(*remoteNode == *m->getRemoteNode());
@@ -365,10 +358,10 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage6()
     Dict dict;
     dict.put("t", String::g(transactionID, DHT_TRANSACTION_ID_LENGTH));
     dict.put("y", "r");
-    SharedHandle<Dict> rDict = Dict::g();
+    std::shared_ptr<Dict> rDict = Dict::g();
     rDict->put("id", String::g(remoteNodeID, DHT_ID_LENGTH));
     std::string compactNodeInfo;
-    SharedHandle<DHTNode> nodes[8];
+    std::shared_ptr<DHTNode> nodes[8];
     for(size_t i = 0; i < DHTBucket::K; ++i) {
       nodes[i].reset(new DHTNode());
       nodes[i]->setIPAddress("2001::000"+util::uitos(i+1));
@@ -385,10 +378,10 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage6()
     }
     rDict->put("nodes6", compactNodeInfo);
 
-    std::deque<SharedHandle<Peer> > peers;
-    SharedHandle<List> valuesList = List::g();
+    std::deque<std::shared_ptr<Peer> > peers;
+    std::shared_ptr<List> valuesList = List::g();
     for(size_t i = 0; i < 4; ++i) {
-      SharedHandle<Peer> peer(new Peer("2001::100"+util::uitos(i+1), 6881+i));
+      std::shared_ptr<Peer> peer(new Peer("2001::100"+util::uitos(i+1), 6881+i));
       unsigned char buffer[COMPACT_LEN_IPV6];
       CPPUNIT_ASSERT_EQUAL
         (COMPACT_LEN_IPV6,
@@ -402,15 +395,14 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage6()
     rDict->put("token", "token");
     dict.put("r", rDict);
 
-    SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
+    std::shared_ptr<DHTNode> remoteNode(new DHTNode(remoteNodeID));
     remoteNode->setIPAddress("2001::2001");
     remoteNode->setPort(6881);
 
-    SharedHandle<DHTGetPeersReplyMessage> m
-      (dynamic_pointer_cast<DHTGetPeersReplyMessage>
-       (factory->createResponseMessage("get_peers", &dict,
-                                       remoteNode->getIPAddress(),
-                                       remoteNode->getPort())));
+    auto m = std::dynamic_pointer_cast<DHTGetPeersReplyMessage>
+      (factory->createResponseMessage("get_peers", &dict,
+                                      remoteNode->getIPAddress(),
+                                      remoteNode->getPort()));
 
     CPPUNIT_ASSERT(*localNode == *m->getLocalNode());
     CPPUNIT_ASSERT(*remoteNode == *m->getRemoteNode());
@@ -438,7 +430,7 @@ void DHTMessageFactoryImplTest::testCreateAnnouncePeerMessage()
     dict.put("t", String::g(transactionID, DHT_TRANSACTION_ID_LENGTH));
     dict.put("y", "q");
     dict.put("q", "announce_peer");
-    SharedHandle<Dict> aDict = Dict::g();
+    std::shared_ptr<Dict> aDict = Dict::g();
     aDict->put("id", String::g(remoteNodeID, DHT_ID_LENGTH));
     unsigned char infoHash[DHT_ID_LENGTH];
     memset(infoHash, 0x11, DHT_ID_LENGTH);
@@ -449,10 +441,9 @@ void DHTMessageFactoryImplTest::testCreateAnnouncePeerMessage()
     aDict->put("token", token);
     dict.put("a", aDict);
 
-    SharedHandle<DHTAnnouncePeerMessage> m
-      (dynamic_pointer_cast<DHTAnnouncePeerMessage>
-       (factory->createQueryMessage(&dict, "192.168.0.1", 6882)));
-    SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
+    auto m = std::dynamic_pointer_cast<DHTAnnouncePeerMessage>
+      (factory->createQueryMessage(&dict, "192.168.0.1", 6882));
+    std::shared_ptr<DHTNode> remoteNode(new DHTNode(remoteNodeID));
     remoteNode->setIPAddress("192.168.0.1");
     remoteNode->setPort(6882);
 
@@ -474,19 +465,18 @@ void DHTMessageFactoryImplTest::testCreateAnnouncePeerReplyMessage()
   Dict dict;
   dict.put("t", String::g(transactionID, DHT_TRANSACTION_ID_LENGTH));
   dict.put("y", "r");
-  SharedHandle<Dict> rDict = Dict::g();
+  std::shared_ptr<Dict> rDict = Dict::g();
   rDict->put("id", String::g(remoteNodeID, DHT_ID_LENGTH));
   dict.put("r", rDict);
 
-  SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode(remoteNodeID));
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
 
-  SharedHandle<DHTAnnouncePeerReplyMessage> m
-    (dynamic_pointer_cast<DHTAnnouncePeerReplyMessage>
-     (factory->createResponseMessage("announce_peer", &dict,
-                                     remoteNode->getIPAddress(),
-                                     remoteNode->getPort())));
+  auto m = std::dynamic_pointer_cast<DHTAnnouncePeerReplyMessage>
+    (factory->createResponseMessage("announce_peer", &dict,
+                                    remoteNode->getIPAddress(),
+                                    remoteNode->getPort()));
 
   CPPUNIT_ASSERT(*localNode == *m->getLocalNode());
   CPPUNIT_ASSERT(*remoteNode == *m->getRemoteNode());
@@ -499,12 +489,12 @@ void DHTMessageFactoryImplTest::testReceivedErrorMessage()
   Dict dict;
   dict.put("t", String::g(transactionID, DHT_TRANSACTION_ID_LENGTH));
   dict.put("y", "e");
-  SharedHandle<List> list = List::g();
+  std::shared_ptr<List> list = List::g();
   list->append(Integer::g(404));
   list->append("Not found");
   dict.put("e", list);
 
-  SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode(remoteNodeID));
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
 
diff --git a/test/DHTMessageTrackerEntryTest.cc b/test/DHTMessageTrackerEntryTest.cc
index 9510f0d1..da1130e1 100644
--- a/test/DHTMessageTrackerEntryTest.cc
+++ b/test/DHTMessageTrackerEntryTest.cc
@@ -33,12 +33,12 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTMessageTrackerEntryTest);
 
 void DHTMessageTrackerEntryTest::testMatch()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
   try {
-    SharedHandle<DHTNode> node1(new DHTNode());
-    SharedHandle<MockDHTMessage> msg1(new MockDHTMessage(localNode, node1));
-    SharedHandle<DHTNode> node2(new DHTNode());
-    SharedHandle<MockDHTMessage> msg2(new MockDHTMessage(localNode, node2));
+    std::shared_ptr<DHTNode> node1(new DHTNode());
+    std::shared_ptr<MockDHTMessage> msg1(new MockDHTMessage(localNode, node1));
+    std::shared_ptr<DHTNode> node2(new DHTNode());
+    std::shared_ptr<MockDHTMessage> msg2(new MockDHTMessage(localNode, node2));
 
     DHTMessageTrackerEntry entry(msg1, 30);
 
diff --git a/test/DHTMessageTrackerTest.cc b/test/DHTMessageTrackerTest.cc
index 301f9709..be23159f 100644
--- a/test/DHTMessageTrackerTest.cc
+++ b/test/DHTMessageTrackerTest.cc
@@ -34,17 +34,17 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTMessageTrackerTest);
 
 void DHTMessageTrackerTest::testMessageArrived()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTRoutingTable> routingTable(new DHTRoutingTable(localNode));
-  SharedHandle<MockDHTMessageFactory> factory(new MockDHTMessageFactory());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTRoutingTable> routingTable(new DHTRoutingTable(localNode));
+  std::shared_ptr<MockDHTMessageFactory> factory(new MockDHTMessageFactory());
   factory->setLocalNode(localNode);
 
-  SharedHandle<MockDHTMessage> m1(new MockDHTMessage(localNode,
-                                                     SharedHandle<DHTNode>(new DHTNode())));
-  SharedHandle<MockDHTMessage> m2(new MockDHTMessage(localNode,
-                                                     SharedHandle<DHTNode>(new DHTNode())));
-  SharedHandle<MockDHTMessage> m3(new MockDHTMessage(localNode,
-                                                     SharedHandle<DHTNode>(new DHTNode())));
+  std::shared_ptr<MockDHTMessage> m1(new MockDHTMessage(localNode,
+                                                     std::shared_ptr<DHTNode>(new DHTNode())));
+  std::shared_ptr<MockDHTMessage> m2(new MockDHTMessage(localNode,
+                                                     std::shared_ptr<DHTNode>(new DHTNode())));
+  std::shared_ptr<MockDHTMessage> m3(new MockDHTMessage(localNode,
+                                                     std::shared_ptr<DHTNode>(new DHTNode())));
 
   m1->getRemoteNode()->setIPAddress("192.168.0.1");
   m1->getRemoteNode()->setPort(6881);
@@ -64,10 +64,10 @@ void DHTMessageTrackerTest::testMessageArrived()
     Dict resDict;
     resDict.put("t", m2->getTransactionID());
 
-    std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> > p =
+    std::pair<std::shared_ptr<DHTMessage>, std::shared_ptr<DHTMessageCallback> > p =
       tracker.messageArrived(&resDict, m2->getRemoteNode()->getIPAddress(),
                              m2->getRemoteNode()->getPort());
-    SharedHandle<DHTMessage> reply = p.first;
+    std::shared_ptr<DHTMessage> reply = p.first;
 
     CPPUNIT_ASSERT(reply);
     CPPUNIT_ASSERT(!tracker.getEntryFor(m2));
@@ -77,10 +77,10 @@ void DHTMessageTrackerTest::testMessageArrived()
     Dict resDict;
     resDict.put("t", m3->getTransactionID());
 
-    std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> > p =
+    std::pair<std::shared_ptr<DHTMessage>, std::shared_ptr<DHTMessageCallback> > p =
       tracker.messageArrived(&resDict, m3->getRemoteNode()->getIPAddress(),
                              m3->getRemoteNode()->getPort());
-    SharedHandle<DHTMessage> reply = p.first;
+    std::shared_ptr<DHTMessage> reply = p.first;
 
     CPPUNIT_ASSERT(reply);
     CPPUNIT_ASSERT(!tracker.getEntryFor(m3));
@@ -90,9 +90,9 @@ void DHTMessageTrackerTest::testMessageArrived()
     Dict resDict;
     resDict.put("t", m1->getTransactionID());
 
-    std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> > p =
+    std::pair<std::shared_ptr<DHTMessage>, std::shared_ptr<DHTMessageCallback> > p =
       tracker.messageArrived(&resDict, "192.168.1.100", 6889);
-    SharedHandle<DHTMessage> reply = p.first;
+    std::shared_ptr<DHTMessage> reply = p.first;
 
     CPPUNIT_ASSERT(!reply);
   }
diff --git a/test/DHTPeerAnnounceEntryTest.cc b/test/DHTPeerAnnounceEntryTest.cc
index aa97d0bc..c9d828da 100644
--- a/test/DHTPeerAnnounceEntryTest.cc
+++ b/test/DHTPeerAnnounceEntryTest.cc
@@ -90,7 +90,7 @@ void DHTPeerAnnounceEntryTest::testGetPeers()
 
   DHTPeerAnnounceEntry entry(infohash);
   {
-    std::vector<SharedHandle<Peer> > peers;
+    std::vector<std::shared_ptr<Peer> > peers;
     entry.getPeers(peers);
     CPPUNIT_ASSERT_EQUAL((size_t)0, peers.size());
   }
@@ -99,7 +99,7 @@ void DHTPeerAnnounceEntryTest::testGetPeers()
   entry.addPeerAddrEntry(PeerAddrEntry("192.168.0.2", 6882));
 
   {
-    std::vector<SharedHandle<Peer> > peers;
+    std::vector<std::shared_ptr<Peer> > peers;
     entry.getPeers(peers);
     CPPUNIT_ASSERT_EQUAL((size_t)2, peers.size());
     CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), peers[0]->getIPAddress());
diff --git a/test/DHTPeerAnnounceStorageTest.cc b/test/DHTPeerAnnounceStorageTest.cc
index 08119a86..b161d806 100644
--- a/test/DHTPeerAnnounceStorageTest.cc
+++ b/test/DHTPeerAnnounceStorageTest.cc
@@ -39,7 +39,7 @@ void DHTPeerAnnounceStorageTest::testAddAnnounce()
   storage.addPeerAnnounce(infohash2, "192.168.0.3", 6883);
   storage.addPeerAnnounce(infohash2, "192.168.0.4", 6884);
 
-  std::vector<SharedHandle<Peer> > peers;
+  std::vector<std::shared_ptr<Peer> > peers;
   storage.getPeers(peers, infohash2);
 
   CPPUNIT_ASSERT_EQUAL((size_t)2, peers.size());
diff --git a/test/DHTPingMessageTest.cc b/test/DHTPingMessageTest.cc
index 7e57e12e..fd4d7bbc 100644
--- a/test/DHTPingMessageTest.cc
+++ b/test/DHTPingMessageTest.cc
@@ -28,12 +28,12 @@ public:
 
   class MockDHTMessageFactory2:public MockDHTMessageFactory {
   public:
-    virtual SharedHandle<DHTResponseMessage>
-    createPingReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+    virtual std::shared_ptr<DHTResponseMessage>
+    createPingReplyMessage(const std::shared_ptr<DHTNode>& remoteNode,
                            const unsigned char* remoteNodeID,
                            const std::string& transactionID)
     {
-      return SharedHandle<MockDHTResponseMessage>
+      return std::shared_ptr<MockDHTResponseMessage>
         (new MockDHTResponseMessage(localNode_, remoteNode, "ping_reply",
                                     transactionID));
     }
@@ -45,8 +45,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTPingMessageTest);
 
 void DHTPingMessageTest::testGetBencodedMessage()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTNode> remoteNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode());
 
   unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
   util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
@@ -62,7 +62,7 @@ void DHTPingMessageTest::testGetBencodedMessage()
   dict.put("v", "A200");
   dict.put("y", "q");
   dict.put("q", "ping");
-  SharedHandle<Dict> aDict = Dict::g();
+  std::shared_ptr<Dict> aDict = Dict::g();
   aDict->put("id", String::g(localNode->getID(), DHT_ID_LENGTH));
   dict.put("a", aDict);
 
@@ -71,8 +71,8 @@ void DHTPingMessageTest::testGetBencodedMessage()
 
 void DHTPingMessageTest::testDoReceivedAction()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTNode> remoteNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode());
 
   unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
   util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
@@ -89,9 +89,8 @@ void DHTPingMessageTest::testDoReceivedAction()
   msg.doReceivedAction();
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher.messageQueue_.size());
-  SharedHandle<MockDHTResponseMessage> m
-    (dynamic_pointer_cast<MockDHTResponseMessage>
-     (dispatcher.messageQueue_[0].message_));
+  auto m = std::dynamic_pointer_cast<MockDHTResponseMessage>
+    (dispatcher.messageQueue_[0].message_);
   CPPUNIT_ASSERT(*localNode == *m->getLocalNode());
   CPPUNIT_ASSERT(*remoteNode == *m->getRemoteNode());
   CPPUNIT_ASSERT_EQUAL(std::string("ping_reply"), m->getMessageType());
diff --git a/test/DHTPingReplyMessageTest.cc b/test/DHTPingReplyMessageTest.cc
index 064b6876..3c4a6238 100644
--- a/test/DHTPingReplyMessageTest.cc
+++ b/test/DHTPingReplyMessageTest.cc
@@ -27,8 +27,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTPingReplyMessageTest);
 
 void DHTPingReplyMessageTest::testGetBencodedMessage()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
-  SharedHandle<DHTNode> remoteNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> remoteNode(new DHTNode());
 
   unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
   util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
@@ -45,7 +45,7 @@ void DHTPingReplyMessageTest::testGetBencodedMessage()
   dict.put("t", transactionID);
   dict.put("v", "A200");
   dict.put("y", "r");
-  SharedHandle<Dict> rDict = Dict::g();
+  std::shared_ptr<Dict> rDict = Dict::g();
   rDict->put("id", String::g(id, DHT_ID_LENGTH));
   dict.put("r", rDict);
 
diff --git a/test/DHTRoutingTableDeserializerTest.cc b/test/DHTRoutingTableDeserializerTest.cc
index c883e1de..ae7ddc3a 100644
--- a/test/DHTRoutingTableDeserializerTest.cc
+++ b/test/DHTRoutingTableDeserializerTest.cc
@@ -37,16 +37,16 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTRoutingTableDeserializerTest);
 
 void DHTRoutingTableDeserializerTest::testDeserialize()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
 
-  SharedHandle<DHTNode> nodesSrc[3];
+  std::shared_ptr<DHTNode> nodesSrc[3];
   for(size_t i = 0; i < A2_ARRAY_LEN(nodesSrc); ++i) {
     nodesSrc[i].reset(new DHTNode());
     nodesSrc[i]->setIPAddress("192.168.0."+util::uitos(i+1));
     nodesSrc[i]->setPort(6881+i);
   }
   nodesSrc[1]->setIPAddress("non-numerical-name");
-  std::vector<SharedHandle<DHTNode> > nodes(vbegin(nodesSrc), vend(nodesSrc));
+  std::vector<std::shared_ptr<DHTNode> > nodes(vbegin(nodesSrc), vend(nodesSrc));
 
   DHTRoutingTableSerializer s(AF_INET);
   s.setLocalNode(localNode);
@@ -64,7 +64,7 @@ void DHTRoutingTableDeserializerTest::testDeserialize()
   std::cout << d.getSerializedTime().getTime() << std::endl;
 
   CPPUNIT_ASSERT_EQUAL((size_t)2, d.getNodes().size());
-  const std::vector<SharedHandle<DHTNode> >& dsnodes = d.getNodes();
+  const std::vector<std::shared_ptr<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);
@@ -75,16 +75,16 @@ void DHTRoutingTableDeserializerTest::testDeserialize()
 
 void DHTRoutingTableDeserializerTest::testDeserialize6()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
 
-  SharedHandle<DHTNode> nodesSrc[3];
+  std::shared_ptr<DHTNode> nodesSrc[3];
   for(size_t i = 0; i < A2_ARRAY_LEN(nodesSrc); ++i) {
     nodesSrc[i].reset(new DHTNode());
     nodesSrc[i]->setIPAddress("2001::100"+util::uitos(i+1));
     nodesSrc[i]->setPort(6881+i);
   }
   nodesSrc[1]->setIPAddress("non-numerical-name");
-  std::vector<SharedHandle<DHTNode> > nodes(vbegin(nodesSrc), vend(nodesSrc));
+  std::vector<std::shared_ptr<DHTNode> > nodes(vbegin(nodesSrc), vend(nodesSrc));
 
   DHTRoutingTableSerializer s(AF_INET6);
   s.setLocalNode(localNode);
@@ -102,7 +102,7 @@ void DHTRoutingTableDeserializerTest::testDeserialize6()
   std::cout << d.getSerializedTime().getTime() << std::endl;
 
   CPPUNIT_ASSERT_EQUAL((size_t)2, d.getNodes().size());
-  const std::vector<SharedHandle<DHTNode> >& dsnodes = d.getNodes();
+  const std::vector<std::shared_ptr<DHTNode> >& dsnodes = d.getNodes();
   CPPUNIT_ASSERT_EQUAL(std::string("2001::1001"), dsnodes[0]->getIPAddress());
   CPPUNIT_ASSERT_EQUAL((uint16_t)6881, dsnodes[0]->getPort());
   CPPUNIT_ASSERT(memcmp(nodes[0]->getID(), dsnodes[0]->getID(),
diff --git a/test/DHTRoutingTableSerializerTest.cc b/test/DHTRoutingTableSerializerTest.cc
index 4a23e9d8..f4b2d480 100644
--- a/test/DHTRoutingTableSerializerTest.cc
+++ b/test/DHTRoutingTableSerializerTest.cc
@@ -27,7 +27,7 @@ private:
   char buf[20];
 
   void checkToLocalnode
-  (std::istream& ss, const SharedHandle<DHTNode>& localNode);
+  (std::istream& ss, const std::shared_ptr<DHTNode>& localNode);
 
   void checkNumNodes(std::istream& ss, size_t expected);
 public:
@@ -47,7 +47,7 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION(DHTRoutingTableSerializerTest);
 
 void DHTRoutingTableSerializerTest::checkToLocalnode
-(std::istream& ss, const SharedHandle<DHTNode>& localNode)
+(std::istream& ss, const std::shared_ptr<DHTNode>& localNode)
 {
   // header
   ss.read(buf, 8);
@@ -98,16 +98,16 @@ void DHTRoutingTableSerializerTest::checkNumNodes
 
 void DHTRoutingTableSerializerTest::testSerialize()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
 
-  SharedHandle<DHTNode> nodesSrc[3];
+  std::shared_ptr<DHTNode> nodesSrc[3];
   for(size_t i = 0; i < A2_ARRAY_LEN(nodesSrc); ++i) {
     nodesSrc[i].reset(new DHTNode());
     nodesSrc[i]->setIPAddress("192.168.0."+util::uitos(i+1));
     nodesSrc[i]->setPort(6881+i);
   }
   nodesSrc[1]->setIPAddress("non-numerical-name");
-  std::vector<SharedHandle<DHTNode> > nodes(vbegin(nodesSrc), vend(nodesSrc));
+  std::vector<std::shared_ptr<DHTNode> > nodes(vbegin(nodesSrc), vend(nodesSrc));
 
   DHTRoutingTableSerializer s(AF_INET);
   s.setLocalNode(localNode);
@@ -226,16 +226,16 @@ void DHTRoutingTableSerializerTest::testSerialize()
 
 void DHTRoutingTableSerializerTest::testSerialize6()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
 
-  SharedHandle<DHTNode> nodesSrc[2];
+  std::shared_ptr<DHTNode> nodesSrc[2];
   for(size_t i = 0; i < A2_ARRAY_LEN(nodesSrc); ++i) {
     nodesSrc[i].reset(new DHTNode());
     nodesSrc[i]->setIPAddress("2001::100"+util::uitos(i+1));
     nodesSrc[i]->setPort(6881+i);
   }
   nodesSrc[1]->setIPAddress("non-numerical-name");
-  std::vector<SharedHandle<DHTNode> > nodes(vbegin(nodesSrc), vend(nodesSrc));
+  std::vector<std::shared_ptr<DHTNode> > nodes(vbegin(nodesSrc), vend(nodesSrc));
 
   DHTRoutingTableSerializer s(AF_INET6);
   s.setLocalNode(localNode);
diff --git a/test/DHTRoutingTableTest.cc b/test/DHTRoutingTableTest.cc
index 1e4598f7..b114d251 100644
--- a/test/DHTRoutingTableTest.cc
+++ b/test/DHTRoutingTableTest.cc
@@ -35,15 +35,15 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTRoutingTableTest);
 
 void DHTRoutingTableTest::testAddNode()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
   DHTRoutingTable table(localNode);
-  SharedHandle<MockDHTTaskFactory> taskFactory(new MockDHTTaskFactory());
+  std::shared_ptr<MockDHTTaskFactory> taskFactory(new MockDHTTaskFactory());
   table.setTaskFactory(taskFactory);
-  SharedHandle<MockDHTTaskQueue> taskQueue(new MockDHTTaskQueue());
+  std::shared_ptr<MockDHTTaskQueue> taskQueue(new MockDHTTaskQueue());
   table.setTaskQueue(taskQueue);
   uint32_t count = 0;
   for(int i = 0; i < 100; ++i) {
-    SharedHandle<DHTNode> node(new DHTNode());
+    std::shared_ptr<DHTNode> node(new DHTNode());
     if(table.addNode(node)) {
       ++count;
     }
@@ -53,14 +53,14 @@ void DHTRoutingTableTest::testAddNode()
 
 void DHTRoutingTableTest::testAddNode_localNode()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
   DHTRoutingTable table(localNode);
-  SharedHandle<MockDHTTaskFactory> taskFactory(new MockDHTTaskFactory());
+  std::shared_ptr<MockDHTTaskFactory> taskFactory(new MockDHTTaskFactory());
   table.setTaskFactory(taskFactory);
-  SharedHandle<MockDHTTaskQueue> taskQueue(new MockDHTTaskQueue());
+  std::shared_ptr<MockDHTTaskQueue> taskQueue(new MockDHTTaskQueue());
   table.setTaskQueue(taskQueue);
 
-  SharedHandle<DHTNode> newNode(new DHTNode(localNode->getID()));
+  std::shared_ptr<DHTNode> newNode(new DHTNode(localNode->getID()));
   CPPUNIT_ASSERT(!table.addNode(newNode));
 }
 
@@ -77,13 +77,13 @@ void DHTRoutingTableTest::testGetClosestKNodes()
 {
   unsigned char id[DHT_ID_LENGTH];
   createID(id, 0x81, 0);
-  SharedHandle<DHTNode> localNode(new DHTNode(id));
+  std::shared_ptr<DHTNode> localNode(new DHTNode(id));
 
   DHTRoutingTable table(localNode);
 
-  SharedHandle<DHTNode> nodes1[8];
-  SharedHandle<DHTNode> nodes2[8];
-  SharedHandle<DHTNode> nodes3[8];
+  std::shared_ptr<DHTNode> nodes1[8];
+  std::shared_ptr<DHTNode> nodes2[8];
+  std::shared_ptr<DHTNode> nodes3[8];
   for(size_t i = 0; i < DHTBucket::K; ++i) {
     createID(id, 0xf0, i);
     nodes1[i].reset(new DHTNode(id));
@@ -101,7 +101,7 @@ void DHTRoutingTableTest::testGetClosestKNodes()
   }
   {
     createID(id, 0x80, 0x10);
-    std::vector<SharedHandle<DHTNode> > nodes;
+    std::vector<std::shared_ptr<DHTNode> > nodes;
     table.getClosestKNodes(nodes, id);
     CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size());
     for(size_t i = 0; i < nodes.size(); ++i) {
diff --git a/test/DHTTaskExecutorTest.cc b/test/DHTTaskExecutorTest.cc
index f66695bd..806afdaf 100644
--- a/test/DHTTaskExecutorTest.cc
+++ b/test/DHTTaskExecutorTest.cc
@@ -20,13 +20,13 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTTaskExecutorTest);
 
 void DHTTaskExecutorTest::testUpdate()
 {
-  SharedHandle<DHTNode> rn;
+  std::shared_ptr<DHTNode> rn;
   DHTTaskExecutor tex(2);
-  SharedHandle<MockDHTTask> tasks[] = {
-    SharedHandle<MockDHTTask>(new MockDHTTask(rn)),
-    SharedHandle<MockDHTTask>(new MockDHTTask(rn)),
-    SharedHandle<MockDHTTask>(new MockDHTTask(rn)),
-    SharedHandle<MockDHTTask>(new MockDHTTask(rn))
+  std::shared_ptr<MockDHTTask> tasks[] = {
+    std::shared_ptr<MockDHTTask>(new MockDHTTask(rn)),
+    std::shared_ptr<MockDHTTask>(new MockDHTTask(rn)),
+    std::shared_ptr<MockDHTTask>(new MockDHTTask(rn)),
+    std::shared_ptr<MockDHTTask>(new MockDHTTask(rn))
   };
   tasks[1]->finished_ = true;
   for(size_t i = 0; i < A2_ARRAY_LEN(tasks); ++i) {
diff --git a/test/DHTUnknownMessageTest.cc b/test/DHTUnknownMessageTest.cc
index 4e399ec0..4f786c2b 100644
--- a/test/DHTUnknownMessageTest.cc
+++ b/test/DHTUnknownMessageTest.cc
@@ -23,7 +23,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTUnknownMessageTest);
 
 void DHTUnknownMessageTest::testToString()
 {
-  SharedHandle<DHTNode> localNode(new DHTNode());
+  std::shared_ptr<DHTNode> localNode(new DHTNode());
   std::string ipaddr = "192.168.0.1";
   uint16_t port = 6881;
 
diff --git a/test/DefaultAuthResolverTest.cc b/test/DefaultAuthResolverTest.cc
index bfac93aa..547321bf 100644
--- a/test/DefaultAuthResolverTest.cc
+++ b/test/DefaultAuthResolverTest.cc
@@ -13,8 +13,8 @@ class DefaultAuthResolverTest : public CppUnit::TestFixture {
   CPPUNIT_TEST_SUITE_END();
 private:
   //NetrcHandle _netrc;
-  //SharedHandle<Option> _option;
-  SharedHandle<DefaultAuthResolver> resolver_;
+  //std::shared_ptr<Option> _option;
+  std::shared_ptr<DefaultAuthResolver> resolver_;
 public:
   void setUp()
   {
@@ -23,7 +23,7 @@ public:
     resolver_.reset(new DefaultAuthResolver());
     //_factory->setOption(_option.get());
     resolver_->setDefaultAuthConfig
-      (SharedHandle<AuthConfig>(new AuthConfig("foo", "bar")));
+      (std::shared_ptr<AuthConfig>(new AuthConfig("foo", "bar")));
   }
 
   void testResolveAuthConfig_without_userDefined();
@@ -35,15 +35,15 @@ CPPUNIT_TEST_SUITE_REGISTRATION( DefaultAuthResolverTest );
 
 void DefaultAuthResolverTest::testResolveAuthConfig_without_userDefined()
 {
-  SharedHandle<AuthConfig> authConfig = resolver_->resolveAuthConfig("localhost");
+  std::shared_ptr<AuthConfig> authConfig = resolver_->resolveAuthConfig("localhost");
   CPPUNIT_ASSERT_EQUAL(std::string("foo:bar"), authConfig->getAuthText());
 }
 
 void DefaultAuthResolverTest::testResolveAuthConfig_with_userDefined()
 {
   resolver_->setUserDefinedAuthConfig
-    (SharedHandle<AuthConfig>(new AuthConfig("myname", "mypasswd")));
-  SharedHandle<AuthConfig> authConfig = resolver_->resolveAuthConfig("localhost");
+    (std::shared_ptr<AuthConfig>(new AuthConfig("myname", "mypasswd")));
+  std::shared_ptr<AuthConfig> authConfig = resolver_->resolveAuthConfig("localhost");
   CPPUNIT_ASSERT_EQUAL(std::string("myname:mypasswd"), authConfig->getAuthText());
 }
 
diff --git a/test/DefaultBtAnnounceTest.cc b/test/DefaultBtAnnounceTest.cc
index 952853ac..455f46e4 100644
--- a/test/DefaultBtAnnounceTest.cc
+++ b/test/DefaultBtAnnounceTest.cc
@@ -39,10 +39,10 @@ class DefaultBtAnnounceTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testProcessUDPTrackerResponse);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<DownloadContext> dctx_;
-  SharedHandle<MockPieceStorage> pieceStorage_;
-  SharedHandle<MockPeerStorage> peerStorage_;
-  SharedHandle<BtRuntime> btRuntime_;
+  std::shared_ptr<DownloadContext> dctx_;
+  std::shared_ptr<MockPieceStorage> pieceStorage_;
+  std::shared_ptr<MockPeerStorage> peerStorage_;
+  std::shared_ptr<BtRuntime> btRuntime_;
   Option* option_;
 public:
   void setUp() {
@@ -60,7 +60,7 @@ public:
     std::string peerId = "-aria2-ultrafastdltl";
 
     dctx_.reset(new DownloadContext(pieceLength, totalLength));
-    SharedHandle<TorrentAttribute> torrentAttrs(new TorrentAttribute());
+    std::shared_ptr<TorrentAttribute> torrentAttrs(new TorrentAttribute());
     torrentAttrs->infoHash = std::string(vbegin(infoHash), vend(infoHash));
     dctx_->setAttribute(CTX_ATTR_BT, torrentAttrs);
     dctx_->getNetStat().updateDownloadLength(pieceLength*5);
@@ -98,10 +98,10 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DefaultBtAnnounceTest);
 
 namespace {
 template<typename InputIterator>
-SharedHandle<List> createAnnounceTier
+std::shared_ptr<List> createAnnounceTier
 (InputIterator first, InputIterator last)
 {
-  SharedHandle<List> announceTier = List::g();
+  std::shared_ptr<List> announceTier = List::g();
   for(; first != last; ++first) {
     announceTier->append(String::g(*first));
   }
@@ -110,17 +110,17 @@ SharedHandle<List> createAnnounceTier
 } // namespace
 
 namespace {
-SharedHandle<List> createAnnounceTier(const std::string& uri)
+std::shared_ptr<List> createAnnounceTier(const std::string& uri)
 {
-  SharedHandle<List> announceTier = List::g();
+  std::shared_ptr<List> announceTier = List::g();
   announceTier->append(String::g(uri));
   return announceTier;
 }
 } // namespace
 
 namespace {
-void setAnnounceList(const SharedHandle<DownloadContext>& dctx,
-                     const SharedHandle<List>& announceList)
+void setAnnounceList(const std::shared_ptr<DownloadContext>& dctx,
+                     const std::shared_ptr<List>& announceList)
 {
   std::vector<std::vector<std::string> > dest;
   for(List::ValueType::const_iterator tierIter = announceList->begin(),
@@ -140,7 +140,7 @@ void setAnnounceList(const SharedHandle<DownloadContext>& dctx,
 
 void DefaultBtAnnounceTest::testNoMoreAnnounce()
 {
-  SharedHandle<List> announceList = List::g();
+  std::shared_ptr<List> announceList = List::g();
   announceList->append(createAnnounceTier("http://localhost/announce"));
   announceList->append(createAnnounceTier("http://backup/announce"));
 
@@ -150,7 +150,7 @@ void DefaultBtAnnounceTest::testNoMoreAnnounce()
   btAnnounce.setPieceStorage(pieceStorage_);
   btAnnounce.setPeerStorage(peerStorage_);
   btAnnounce.setBtRuntime(btRuntime_);
-  btAnnounce.setRandomizer(SharedHandle<Randomizer>(new FixedNumberRandomizer()));
+  btAnnounce.setRandomizer(std::shared_ptr<Randomizer>(new FixedNumberRandomizer()));
   btAnnounce.setTcpPort(6989);
 
   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=fastdltl&numwant=50&no_peer_id=1&port=6989&event=started&supportcrypto=1"), btAnnounce.getAnnounceUrl());
@@ -191,7 +191,7 @@ void DefaultBtAnnounceTest::testNoMoreAnnounce()
 void DefaultBtAnnounceTest::testGetAnnounceUrl()
 {
 
-  SharedHandle<List> announceList = List::g();
+  std::shared_ptr<List> announceList = List::g();
   announceList->append(createAnnounceTier("http://localhost/announce"));
   setAnnounceList(dctx_, announceList);
 
@@ -199,9 +199,9 @@ void DefaultBtAnnounceTest::testGetAnnounceUrl()
   btAnnounce.setPieceStorage(pieceStorage_);
   btAnnounce.setPeerStorage(peerStorage_);
   btAnnounce.setBtRuntime(btRuntime_);
-  btAnnounce.setRandomizer(SharedHandle<Randomizer>(new FixedNumberRandomizer()));
+  btAnnounce.setRandomizer(std::shared_ptr<Randomizer>(new FixedNumberRandomizer()));
   btAnnounce.setTcpPort(6989);
-  SharedHandle<UDPTrackerRequest> req;
+  std::shared_ptr<UDPTrackerRequest> req;
 
   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=fastdltl&numwant=50&no_peer_id=1&port=6989&event=started&supportcrypto=1"), btAnnounce.getAnnounceUrl());
   req = btAnnounce.createUDPTrackerRequest("localhost", 80, 6989);
@@ -248,7 +248,7 @@ void DefaultBtAnnounceTest::testGetAnnounceUrl()
 
 void DefaultBtAnnounceTest::testGetAnnounceUrl_withQuery()
 {
-  SharedHandle<List> announceList = List::g();
+  std::shared_ptr<List> announceList = List::g();
   announceList->append(createAnnounceTier("http://localhost/announce?k=v"));
   setAnnounceList(dctx_, announceList);
 
@@ -256,7 +256,7 @@ void DefaultBtAnnounceTest::testGetAnnounceUrl_withQuery()
   btAnnounce.setPieceStorage(pieceStorage_);
   btAnnounce.setPeerStorage(peerStorage_);
   btAnnounce.setBtRuntime(btRuntime_);
-  btAnnounce.setRandomizer(SharedHandle<Randomizer>(new FixedNumberRandomizer()));
+  btAnnounce.setRandomizer(std::shared_ptr<Randomizer>(new FixedNumberRandomizer()));
   btAnnounce.setTcpPort(6989);
 
   CPPUNIT_ASSERT_EQUAL
@@ -271,7 +271,7 @@ void DefaultBtAnnounceTest::testGetAnnounceUrl_withQuery()
 
 void DefaultBtAnnounceTest::testGetAnnounceUrl_externalIP()
 {
-  SharedHandle<List> announceList = List::g();
+  std::shared_ptr<List> announceList = List::g();
   announceList->append(createAnnounceTier("http://localhost/announce"));
   setAnnounceList(dctx_, announceList);
 
@@ -280,7 +280,7 @@ void DefaultBtAnnounceTest::testGetAnnounceUrl_externalIP()
   btAnnounce.setPieceStorage(pieceStorage_);
   btAnnounce.setPeerStorage(peerStorage_);
   btAnnounce.setBtRuntime(btRuntime_);
-  btAnnounce.setRandomizer(SharedHandle<Randomizer>(new FixedNumberRandomizer()));
+  btAnnounce.setRandomizer(std::shared_ptr<Randomizer>(new FixedNumberRandomizer()));
   btAnnounce.setTcpPort(6989);
 
   CPPUNIT_ASSERT_EQUAL
@@ -292,7 +292,7 @@ void DefaultBtAnnounceTest::testGetAnnounceUrl_externalIP()
                  "supportcrypto=1&ip=192.168.1.1"),
      btAnnounce.getAnnounceUrl());
 
-  SharedHandle<UDPTrackerRequest> req;
+  std::shared_ptr<UDPTrackerRequest> req;
   req = btAnnounce.createUDPTrackerRequest("localhost", 80, 6989);
   char host[NI_MAXHOST];
   int rv = inetNtop(AF_INET, &req->ip, host, sizeof(host));
@@ -302,7 +302,7 @@ void DefaultBtAnnounceTest::testGetAnnounceUrl_externalIP()
 
 void DefaultBtAnnounceTest::testIsAllAnnounceFailed()
 {
-  SharedHandle<List> announceList = List::g();
+  std::shared_ptr<List> announceList = List::g();
   announceList->append(createAnnounceTier("http://localhost/announce"));
   announceList->append(createAnnounceTier("http://backup/announce"));
   setAnnounceList(dctx_, announceList);
@@ -311,7 +311,7 @@ void DefaultBtAnnounceTest::testIsAllAnnounceFailed()
   btAnnounce.setPieceStorage(pieceStorage_);
   btAnnounce.setPeerStorage(peerStorage_);
   btAnnounce.setBtRuntime(btRuntime_);
-  btAnnounce.setRandomizer(SharedHandle<Randomizer>(new FixedNumberRandomizer()));
+  btAnnounce.setRandomizer(std::shared_ptr<Randomizer>(new FixedNumberRandomizer()));
   btAnnounce.setTcpPort(6989);
 
   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=fastdltl&numwant=50&no_peer_id=1&port=6989&event=started&supportcrypto=1"), btAnnounce.getAnnounceUrl());
@@ -336,7 +336,7 @@ void DefaultBtAnnounceTest::testURLOrderInStoppedEvent()
   const char* urls[] = { "http://localhost1/announce",
                          "http://localhost2/announce" };
 
-  SharedHandle<List> announceList = List::g();
+  std::shared_ptr<List> announceList = List::g();
   announceList->append(createAnnounceTier(vbegin(urls), vend(urls)));
   setAnnounceList(dctx_, announceList);
 
@@ -344,7 +344,7 @@ void DefaultBtAnnounceTest::testURLOrderInStoppedEvent()
   btAnnounce.setPieceStorage(pieceStorage_);
   btAnnounce.setPeerStorage(peerStorage_);
   btAnnounce.setBtRuntime(btRuntime_);
-  btAnnounce.setRandomizer(SharedHandle<Randomizer>(new FixedNumberRandomizer()));
+  btAnnounce.setRandomizer(std::shared_ptr<Randomizer>(new FixedNumberRandomizer()));
   btAnnounce.setTcpPort(6989);
 
   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=fastdltl&numwant=50&no_peer_id=1&port=6989&event=started&supportcrypto=1"), btAnnounce.getAnnounceUrl());
@@ -367,7 +367,7 @@ void DefaultBtAnnounceTest::testURLOrderInCompletedEvent()
   const char* urls[] = { "http://localhost1/announce",
                          "http://localhost2/announce" };
 
-  SharedHandle<List> announceList = List::g();
+  std::shared_ptr<List> announceList = List::g();
   announceList->append(createAnnounceTier(vbegin(urls), vend(urls)));
   setAnnounceList(dctx_, announceList);
 
@@ -375,7 +375,7 @@ void DefaultBtAnnounceTest::testURLOrderInCompletedEvent()
   btAnnounce.setPieceStorage(pieceStorage_);
   btAnnounce.setPeerStorage(peerStorage_);
   btAnnounce.setBtRuntime(btRuntime_);
-  btAnnounce.setRandomizer(SharedHandle<Randomizer>(new FixedNumberRandomizer()));
+  btAnnounce.setRandomizer(std::shared_ptr<Randomizer>(new FixedNumberRandomizer()));
   btAnnounce.setTcpPort(6989);
 
   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=fastdltl&numwant=50&no_peer_id=1&port=6989&event=started&supportcrypto=1"), btAnnounce.getAnnounceUrl());
@@ -440,7 +440,7 @@ void DefaultBtAnnounceTest::testProcessAnnounceResponse()
   CPPUNIT_ASSERT_EQUAL(100, an.getComplete());
   CPPUNIT_ASSERT_EQUAL(200, an.getIncomplete());
   CPPUNIT_ASSERT_EQUAL((size_t)2, peerStorage_->getUnusedPeers().size());
-  SharedHandle<Peer> peer = peerStorage_->getUnusedPeers()[0];
+  std::shared_ptr<Peer> peer = peerStorage_->getUnusedPeers()[0];
   CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), peer->getIPAddress());
   peer = peerStorage_->getUnusedPeers()[1];
   CPPUNIT_ASSERT_EQUAL(std::string("1002:1035:4527:3546:7854:1237:3247:3217"),
@@ -449,9 +449,9 @@ void DefaultBtAnnounceTest::testProcessAnnounceResponse()
 
 void DefaultBtAnnounceTest::testProcessUDPTrackerResponse()
 {
-  SharedHandle<UDPTrackerRequest> req(new UDPTrackerRequest());
+  std::shared_ptr<UDPTrackerRequest> req(new UDPTrackerRequest());
   req->action = UDPT_ACT_ANNOUNCE;
-  SharedHandle<UDPTrackerReply> reply(new UDPTrackerReply());
+  std::shared_ptr<UDPTrackerReply> reply(new UDPTrackerReply());
   reply->interval = 1800;
   reply->leechers = 200;
   reply->seeders = 100;
@@ -470,7 +470,7 @@ void DefaultBtAnnounceTest::testProcessUDPTrackerResponse()
   CPPUNIT_ASSERT_EQUAL(200, an.getIncomplete());
   CPPUNIT_ASSERT_EQUAL((size_t)2, peerStorage_->getUnusedPeers().size());
   for(int i = 0; i < 2; ++i) {
-    SharedHandle<Peer> peer;
+    std::shared_ptr<Peer> peer;
     peer = peerStorage_->getUnusedPeers()[i];
     CPPUNIT_ASSERT_EQUAL("192.168.0."+util::uitos(i+1), peer->getIPAddress());
     CPPUNIT_ASSERT_EQUAL((uint16_t)(6890+i), peer->getPort());
diff --git a/test/DefaultBtMessageDispatcherTest.cc b/test/DefaultBtMessageDispatcherTest.cc
index 89076824..949deebd 100644
--- a/test/DefaultBtMessageDispatcherTest.cc
+++ b/test/DefaultBtMessageDispatcherTest.cc
@@ -41,15 +41,15 @@ class DefaultBtMessageDispatcherTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testRemoveOutstandingRequest);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<DownloadContext> dctx_;
-  SharedHandle<Peer> peer;
-  SharedHandle<DefaultBtMessageDispatcher> btMessageDispatcher;
-  SharedHandle<MockPeerStorage> peerStorage;
-  SharedHandle<MockPieceStorage> pieceStorage;
-  SharedHandle<MockBtMessageFactory> messageFactory_;
-  SharedHandle<RequestGroupMan> rgman_;
-  SharedHandle<Option> option_;
-  SharedHandle<RequestGroup> rg_;
+  std::shared_ptr<DownloadContext> dctx_;
+  std::shared_ptr<Peer> peer;
+  std::shared_ptr<DefaultBtMessageDispatcher> btMessageDispatcher;
+  std::shared_ptr<MockPeerStorage> peerStorage;
+  std::shared_ptr<MockPieceStorage> pieceStorage;
+  std::shared_ptr<MockBtMessageFactory> messageFactory_;
+  std::shared_ptr<RequestGroupMan> rgman_;
+  std::shared_ptr<Option> option_;
+  std::shared_ptr<RequestGroup> rg_;
 public:
   void tearDown() {}
 
@@ -110,22 +110,22 @@ public:
 
   class MockPieceStorage2 : public MockPieceStorage {
   private:
-    SharedHandle<Piece> piece;
+    std::shared_ptr<Piece> piece;
   public:
-    virtual SharedHandle<Piece> getPiece(size_t index) {
+    virtual std::shared_ptr<Piece> getPiece(size_t index) {
       return piece;
     }
 
-    void setPiece(const SharedHandle<Piece>& piece) {
+    void setPiece(const std::shared_ptr<Piece>& piece) {
       this->piece = piece;
     }
   };
 
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual SharedHandle<BtMessage>
+    virtual std::shared_ptr<BtMessage>
     createCancelMessage(size_t index, int32_t begin, int32_t length) {
-      SharedHandle<MockBtMessage2> btMsg(new MockBtMessage2());
+      std::shared_ptr<MockBtMessage2> btMsg(new MockBtMessage2());
       btMsg->type = "cancel";
       return btMsg;
     }
@@ -150,7 +150,7 @@ public:
 
     messageFactory_.reset(new MockBtMessageFactory2());
 
-    rgman_.reset(new RequestGroupMan(std::vector<SharedHandle<RequestGroup> >(),
+    rgman_.reset(new RequestGroupMan(std::vector<std::shared_ptr<RequestGroup> >(),
                                      0, option_.get()));
 
     btMessageDispatcher.reset(new DefaultBtMessageDispatcher());
@@ -168,7 +168,7 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION(DefaultBtMessageDispatcherTest);
 
 void DefaultBtMessageDispatcherTest::testAddMessage() {
-  SharedHandle<MockBtMessage2> msg(new MockBtMessage2());
+  std::shared_ptr<MockBtMessage2> msg(new MockBtMessage2());
   CPPUNIT_ASSERT_EQUAL(false, msg->isOnQueuedCalled());
   btMessageDispatcher->addMessageToQueue(msg);
   CPPUNIT_ASSERT_EQUAL(true, msg->isOnQueuedCalled());
@@ -177,9 +177,9 @@ void DefaultBtMessageDispatcherTest::testAddMessage() {
 }
 
 void DefaultBtMessageDispatcherTest::testSendMessages() {
-  SharedHandle<MockBtMessage2> msg1(new MockBtMessage2());
+  std::shared_ptr<MockBtMessage2> msg1(new MockBtMessage2());
   msg1->setUploading(false);
-  SharedHandle<MockBtMessage2> msg2(new MockBtMessage2());
+  std::shared_ptr<MockBtMessage2> msg2(new MockBtMessage2());
   msg2->setUploading(false);
   btMessageDispatcher->addMessageToQueue(msg1);
   btMessageDispatcher->addMessageToQueue(msg2);
@@ -190,9 +190,9 @@ void DefaultBtMessageDispatcherTest::testSendMessages() {
 }
 
 void DefaultBtMessageDispatcherTest::testSendMessages_underUploadLimit() {
-  SharedHandle<MockBtMessage2> msg1(new MockBtMessage2());
+  std::shared_ptr<MockBtMessage2> msg1(new MockBtMessage2());
   msg1->setUploading(true);
-  SharedHandle<MockBtMessage2> msg2(new MockBtMessage2());
+  std::shared_ptr<MockBtMessage2> msg2(new MockBtMessage2());
   msg2->setUploading(true);
   btMessageDispatcher->addMessageToQueue(msg1);
   btMessageDispatcher->addMessageToQueue(msg2);
@@ -212,11 +212,11 @@ void DefaultBtMessageDispatcherTest::testSendMessages_underUploadLimit() {
 //   stat.setUploadSpeed(150);
 //   peerStorage->setStat(stat);
 
-//   SharedHandle<MockBtMessage2> msg1(new MockBtMessage2());
+//   std::shared_ptr<MockBtMessage2> msg1(new MockBtMessage2());
 //   msg1->setUploading(true);
-//   SharedHandle<MockBtMessage2> msg2(new MockBtMessage2());
+//   std::shared_ptr<MockBtMessage2> msg2(new MockBtMessage2());
 //   msg2->setUploading(true);
-//   SharedHandle<MockBtMessage2> msg3(new MockBtMessage2());
+//   std::shared_ptr<MockBtMessage2> msg3(new MockBtMessage2());
 //   msg3->setUploading(false);
 
 //   btMessageDispatcher->addMessageToQueue(msg1);
@@ -233,8 +233,8 @@ void DefaultBtMessageDispatcherTest::testSendMessages_underUploadLimit() {
 // }
 
 void DefaultBtMessageDispatcherTest::testDoCancelSendingPieceAction() {
-  SharedHandle<MockBtMessage2> msg1(new MockBtMessage2());
-  SharedHandle<MockBtMessage2> msg2(new MockBtMessage2());
+  std::shared_ptr<MockBtMessage2> msg1(new MockBtMessage2());
+  std::shared_ptr<MockBtMessage2> msg2(new MockBtMessage2());
 
   btMessageDispatcher->addMessageToQueue(msg1);
   btMessageDispatcher->addMessageToQueue(msg2);
@@ -248,14 +248,14 @@ void DefaultBtMessageDispatcherTest::testDoCancelSendingPieceAction() {
 int MY_PIECE_LENGTH = 16*1024;
 
 void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing() {
-  SharedHandle<Piece> piece(new Piece(0, MY_PIECE_LENGTH));
+  std::shared_ptr<Piece> piece(new Piece(0, MY_PIECE_LENGTH));
   RequestSlot slot(0, 0, MY_PIECE_LENGTH, 0, piece);
 
   size_t index;
   CPPUNIT_ASSERT(piece->getMissingUnusedBlockIndex(index));
   CPPUNIT_ASSERT_EQUAL((size_t)0, index);
 
-  SharedHandle<MockPieceStorage2> pieceStorage(new MockPieceStorage2());
+  std::shared_ptr<MockPieceStorage2> pieceStorage(new MockPieceStorage2());
   pieceStorage->setPiece(piece);
 
   btMessageDispatcher->setRequestTimeout(60);
@@ -271,7 +271,7 @@ void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing() {
 }
 
 void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing_timeout() {
-  SharedHandle<Piece> piece(new Piece(0, MY_PIECE_LENGTH));
+  std::shared_ptr<Piece> piece(new Piece(0, MY_PIECE_LENGTH));
   RequestSlot slot(0, 0, MY_PIECE_LENGTH, 0, piece);
   // make this slot timeout
   slot.setDispatchedTime(0);
@@ -280,7 +280,7 @@ void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing_tim
   CPPUNIT_ASSERT(piece->getMissingUnusedBlockIndex(index));
   CPPUNIT_ASSERT_EQUAL((size_t)0, index);
 
-  SharedHandle<MockPieceStorage2> pieceStorage(new MockPieceStorage2());
+  std::shared_ptr<MockPieceStorage2> pieceStorage(new MockPieceStorage2());
   pieceStorage->setPiece(piece);
 
   btMessageDispatcher->setRequestTimeout(60);
@@ -298,12 +298,12 @@ void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing_tim
 }
 
 void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing_completeBlock() {
-  SharedHandle<Piece> piece(new Piece(0, MY_PIECE_LENGTH));
+  std::shared_ptr<Piece> piece(new Piece(0, MY_PIECE_LENGTH));
   piece->completeBlock(0);
 
   RequestSlot slot(0, 0, MY_PIECE_LENGTH, 0, piece);
 
-  SharedHandle<MockPieceStorage2> pieceStorage(new MockPieceStorage2());
+  std::shared_ptr<MockPieceStorage2> pieceStorage(new MockPieceStorage2());
   pieceStorage->setPiece(piece);
 
   btMessageDispatcher->setRequestTimeout(60);
@@ -354,7 +354,7 @@ void DefaultBtMessageDispatcherTest::testGetOutstandingRequest() {
 }
 
 void DefaultBtMessageDispatcherTest::testRemoveOutstandingRequest() {
-  SharedHandle<Piece> piece(new Piece(1, 1024*1024));
+  std::shared_ptr<Piece> piece(new Piece(1, 1024*1024));
   size_t blockIndex = 0;
   CPPUNIT_ASSERT(piece->getMissingUnusedBlockIndex(blockIndex));
   uint32_t begin = blockIndex*piece->getBlockLength();
diff --git a/test/DefaultBtMessageFactoryTest.cc b/test/DefaultBtMessageFactoryTest.cc
index a4011009..94f6d87f 100644
--- a/test/DefaultBtMessageFactoryTest.cc
+++ b/test/DefaultBtMessageFactoryTest.cc
@@ -24,10 +24,10 @@ class DefaultBtMessageFactoryTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testCreatePortMessage);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<DownloadContext> dctx_;
-  SharedHandle<Peer> peer_;
-  SharedHandle<MockExtensionMessageFactory> exmsgFactory_;
-  SharedHandle<DefaultBtMessageFactory> factory_;
+  std::shared_ptr<DownloadContext> dctx_;
+  std::shared_ptr<Peer> peer_;
+  std::shared_ptr<MockExtensionMessageFactory> exmsgFactory_;
+  std::shared_ptr<DefaultBtMessageFactory> factory_;
 public:
   void setUp()
   {
@@ -62,9 +62,8 @@ void DefaultBtMessageFactoryTest::testCreateBtMessage_BtExtendedMessage()
   msg[5] = 1; // Set dummy extended message ID 1
   memcpy(msg+6, payload.c_str(), payload.size());
 
-  SharedHandle<BtExtendedMessage> m
-    (dynamic_pointer_cast<BtExtendedMessage>
-     (factory_->createBtMessage((const unsigned char*)msg+4, sizeof(msg))));
+  auto m = std::dynamic_pointer_cast<BtExtendedMessage>
+    (factory_->createBtMessage((const unsigned char*)msg+4, sizeof(msg)));
 
   try {
     // disable extended messaging
@@ -83,9 +82,8 @@ void DefaultBtMessageFactoryTest::testCreatePortMessage()
     bittorrent::createPeerMessageString(data, sizeof(data), 3, 9);
     bittorrent::setShortIntParam(&data[5], 6881);
     try {
-      SharedHandle<BtPortMessage> m
-        (dynamic_pointer_cast<BtPortMessage>
-         (factory_->createBtMessage(&data[4], sizeof(data)-4)));
+      auto m = std::dynamic_pointer_cast<BtPortMessage>
+        (factory_->createBtMessage(&data[4], sizeof(data)-4));
       CPPUNIT_ASSERT(m);
       CPPUNIT_ASSERT_EQUAL((uint16_t)6881, m->getPort());
     } catch(Exception& e) {
@@ -93,8 +91,8 @@ void DefaultBtMessageFactoryTest::testCreatePortMessage()
     }
   }
   {
-    SharedHandle<BtPortMessage> m
-      (dynamic_pointer_cast<BtPortMessage>(factory_->createPortMessage(6881)));
+    auto m = std::dynamic_pointer_cast<BtPortMessage>
+      (factory_->createPortMessage(6881));
     CPPUNIT_ASSERT_EQUAL((uint16_t)6881, m->getPort());
   }
 }
diff --git a/test/DefaultBtProgressInfoFileTest.cc b/test/DefaultBtProgressInfoFileTest.cc
index 48786c3c..8e0dad88 100644
--- a/test/DefaultBtProgressInfoFileTest.cc
+++ b/test/DefaultBtProgressInfoFileTest.cc
@@ -42,16 +42,16 @@ class DefaultBtProgressInfoFileTest:public CppUnit::TestFixture {
 private:
 
 #ifdef ENABLE_BITTORRENT
-  SharedHandle<DownloadContext> dctx_;
+  std::shared_ptr<DownloadContext> dctx_;
 
-  SharedHandle<MockPeerStorage> peerStorage_;
+  std::shared_ptr<MockPeerStorage> peerStorage_;
 
-  SharedHandle<BtRuntime> btRuntime_;
+  std::shared_ptr<BtRuntime> btRuntime_;
 #endif // ENABLE_BITTORRENT
 
-  SharedHandle<MockPieceStorage> pieceStorage_;
-  SharedHandle<Option> option_;
-  SharedHandle<BitfieldMan> bitfield_;
+  std::shared_ptr<MockPieceStorage> pieceStorage_;
+  std::shared_ptr<Option> option_;
+  std::shared_ptr<BitfieldMan> bitfield_;
 public:
   void initializeMembers(int32_t pieceLength, int64_t totalLength)
   {
@@ -70,11 +70,11 @@ public:
     };
 
     dctx_.reset(new DownloadContext());
-    SharedHandle<TorrentAttribute> torrentAttrs(new TorrentAttribute());
+    std::shared_ptr<TorrentAttribute> torrentAttrs(new TorrentAttribute());
     torrentAttrs->infoHash = std::string(vbegin(infoHash), vend(infoHash));
     dctx_->setAttribute(CTX_ATTR_BT, torrentAttrs);
-    const SharedHandle<FileEntry> fileEntries[] = {
-      SharedHandle<FileEntry>(new FileEntry("/path/to/file",totalLength,0))
+    const std::shared_ptr<FileEntry> fileEntries[] = {
+      std::shared_ptr<FileEntry>(new FileEntry("/path/to/file",totalLength,0))
     };
     dctx_->setFileEntries(vbegin(fileEntries), vend(fileEntries));
     dctx_->setPieceLength(pieceLength);
@@ -141,10 +141,10 @@ void DefaultBtProgressInfoFileTest::testLoad_compat()
                        pieceStorage_->countInFlightPiece());
 
   // piece index 1
-  std::vector<SharedHandle<Piece> > inFlightPieces;
+  std::vector<std::shared_ptr<Piece> > inFlightPieces;
   pieceStorage_->getInFlightPieces(inFlightPieces);
 
-  SharedHandle<Piece> piece1 = inFlightPieces[0];
+  std::shared_ptr<Piece> piece1 = inFlightPieces[0];
   CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex());
   CPPUNIT_ASSERT_EQUAL(1024, piece1->getLength());
   CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getBitfieldLength());
@@ -152,7 +152,7 @@ void DefaultBtProgressInfoFileTest::testLoad_compat()
                                                       piece1->getBitfieldLength()));
 
   // piece index 2
-  SharedHandle<Piece> piece2 = inFlightPieces[1];
+  std::shared_ptr<Piece> piece2 = inFlightPieces[1];
   CPPUNIT_ASSERT_EQUAL((size_t)2, piece2->getIndex());
   CPPUNIT_ASSERT_EQUAL(512, piece2->getLength());
 }
@@ -190,10 +190,10 @@ void DefaultBtProgressInfoFileTest::testLoad()
                        pieceStorage_->countInFlightPiece());
 
   // piece index 1
-  std::vector<SharedHandle<Piece> > inFlightPieces;
+  std::vector<std::shared_ptr<Piece> > inFlightPieces;
   pieceStorage_->getInFlightPieces(inFlightPieces);
 
-  SharedHandle<Piece> piece1 = inFlightPieces[0];
+  std::shared_ptr<Piece> piece1 = inFlightPieces[0];
   CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex());
   CPPUNIT_ASSERT_EQUAL(1024, piece1->getLength());
   CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getBitfieldLength());
@@ -201,7 +201,7 @@ void DefaultBtProgressInfoFileTest::testLoad()
                                                       piece1->getBitfieldLength()));
 
   // piece index 2
-  SharedHandle<Piece> piece2 = inFlightPieces[1];
+  std::shared_ptr<Piece> piece2 = inFlightPieces[1];
   CPPUNIT_ASSERT_EQUAL((size_t)2, piece2->getIndex());
   CPPUNIT_ASSERT_EQUAL(512, piece2->getLength());
 }
@@ -217,9 +217,9 @@ void DefaultBtProgressInfoFileTest::testSave()
   bitfield_->unsetBit(79);
   pieceStorage_->setCompletedLength(80896);
 
-  SharedHandle<Piece> p1(new Piece(1, 1024));
-  SharedHandle<Piece> p2(new Piece(2, 512));
-  std::vector<SharedHandle<Piece> > inFlightPieces;
+  std::shared_ptr<Piece> p1(new Piece(1, 1024));
+  std::shared_ptr<Piece> p2(new Piece(2, 512));
+  std::vector<std::shared_ptr<Piece> > inFlightPieces;
   inFlightPieces.push_back(p1);
   inFlightPieces.push_back(p2);
   pieceStorage_->addInFlightPiece(inFlightPieces);
@@ -330,7 +330,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_compat()
 {
   initializeMembers(1024, 81920);
 
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(1024, 81920, A2_TEST_DIR"/load-nonBt"));
 
   DefaultBtProgressInfoFile infoFile(dctx, pieceStorage_, option_.get());
@@ -354,10 +354,10 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_compat()
                        pieceStorage_->countInFlightPiece());
 
   // piece index 1
-  std::vector<SharedHandle<Piece> > inFlightPieces;
+  std::vector<std::shared_ptr<Piece> > inFlightPieces;
   pieceStorage_->getInFlightPieces(inFlightPieces);
 
-  SharedHandle<Piece> piece1 = inFlightPieces[0];
+  std::shared_ptr<Piece> piece1 = inFlightPieces[0];
   CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex());
   CPPUNIT_ASSERT_EQUAL(1024, piece1->getLength());
   CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getBitfieldLength());
@@ -365,7 +365,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_compat()
                                                       piece1->getBitfieldLength()));
 
   // piece index 2
-  SharedHandle<Piece> piece2 = inFlightPieces[1];
+  std::shared_ptr<Piece> piece2 = inFlightPieces[1];
   CPPUNIT_ASSERT_EQUAL((size_t)2, piece2->getIndex());
   CPPUNIT_ASSERT_EQUAL(512, piece2->getLength());
 }
@@ -375,7 +375,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt()
 {
   initializeMembers(1024, 81920);
 
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(1024, 81920, A2_TEST_DIR"/load-nonBt-v0001"));
 
   DefaultBtProgressInfoFile infoFile(dctx, pieceStorage_, option_.get());
@@ -399,10 +399,10 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt()
                        pieceStorage_->countInFlightPiece());
 
   // piece index 1
-  std::vector<SharedHandle<Piece> > inFlightPieces;
+  std::vector<std::shared_ptr<Piece> > inFlightPieces;
   pieceStorage_->getInFlightPieces(inFlightPieces);
 
-  SharedHandle<Piece> piece1 = inFlightPieces[0];
+  std::shared_ptr<Piece> piece1 = inFlightPieces[0];
   CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex());
   CPPUNIT_ASSERT_EQUAL(1024, piece1->getLength());
   CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getBitfieldLength());
@@ -410,7 +410,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt()
                                                       piece1->getBitfieldLength()));
 
   // piece index 2
-  SharedHandle<Piece> piece2 = inFlightPieces[1];
+  std::shared_ptr<Piece> piece2 = inFlightPieces[1];
   CPPUNIT_ASSERT_EQUAL((size_t)2, piece2->getIndex());
   CPPUNIT_ASSERT_EQUAL(512, piece2->getLength());
 }
@@ -420,7 +420,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_pieceLengthShorter()
   initializeMembers(512, 81920);
   option_->put(PREF_ALLOW_PIECE_LENGTH_CHANGE, A2_V_TRUE);
 
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(512, 81920, A2_TEST_DIR"/load-nonBt-v0001"));
 
   DefaultBtProgressInfoFile infoFile(dctx, pieceStorage_, option_.get());
@@ -445,16 +445,16 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt()
 {
   initializeMembers(1024, 81920);
 
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(1024, 81920, A2_TEST_OUT_DIR"/save-temp"));
 
   bitfield_->setAllBit();
   bitfield_->unsetBit(79);
   pieceStorage_->setCompletedLength(80896);
 
-  SharedHandle<Piece> p1(new Piece(1, 1024));
-  SharedHandle<Piece> p2(new Piece(2, 512));
-  std::vector<SharedHandle<Piece> > inFlightPieces;
+  std::shared_ptr<Piece> p1(new Piece(1, 1024));
+  std::shared_ptr<Piece> p2(new Piece(2, 512));
+  std::vector<std::shared_ptr<Piece> > inFlightPieces;
   inFlightPieces.push_back(p1);
   inFlightPieces.push_back(p2);
   pieceStorage_->addInFlightPiece(inFlightPieces);
@@ -552,10 +552,10 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt()
 
 void DefaultBtProgressInfoFileTest::testUpdateFilename()
 {
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(1024, 81920, A2_TEST_DIR"/file1"));
 
-  DefaultBtProgressInfoFile infoFile(dctx, SharedHandle<MockPieceStorage>(), 0);
+  DefaultBtProgressInfoFile infoFile(dctx, std::shared_ptr<MockPieceStorage>(), 0);
 #ifdef ENABLE_BITTORRENT
   infoFile.setBtRuntime(btRuntime_);
   infoFile.setPeerStorage(peerStorage_);
diff --git a/test/DefaultBtRequestFactoryTest.cc b/test/DefaultBtRequestFactoryTest.cc
index 61d49fa8..3b17982d 100644
--- a/test/DefaultBtRequestFactoryTest.cc
+++ b/test/DefaultBtRequestFactoryTest.cc
@@ -27,12 +27,12 @@ class DefaultBtRequestFactoryTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testGetTargetPieceIndexes);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<Peer> peer_;
-  SharedHandle<DefaultBtRequestFactory> requestFactory_;
-  SharedHandle<DownloadContext> dctx_;
-  SharedHandle<MockPieceStorage> pieceStorage_;
-  SharedHandle<MockBtMessageFactory> messageFactory_;
-  SharedHandle<MockBtMessageDispatcher> dispatcher_;
+  std::shared_ptr<Peer> peer_;
+  std::shared_ptr<DefaultBtRequestFactory> requestFactory_;
+  std::shared_ptr<DownloadContext> dctx_;
+  std::shared_ptr<MockPieceStorage> pieceStorage_;
+  std::shared_ptr<MockBtMessageFactory> messageFactory_;
+  std::shared_ptr<MockBtMessageDispatcher> dispatcher_;
 public:
   void testAddTargetPiece();
   void testRemoveCompletedPiece();
@@ -50,13 +50,13 @@ public:
       index(index), blockIndex(blockIndex) {}
   };
 
-  typedef SharedHandle<MockBtRequestMessage> MockBtRequestMessageHandle;
+  typedef std::shared_ptr<MockBtRequestMessage> MockBtRequestMessageHandle;
 
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual SharedHandle<BtMessage>
-    createRequestMessage(const SharedHandle<Piece>& piece, size_t blockIndex) {
-      return SharedHandle<BtMessage>
+    virtual std::shared_ptr<BtMessage>
+    createRequestMessage(const std::shared_ptr<Piece>& piece, size_t blockIndex) {
+      return std::shared_ptr<BtMessage>
         (new MockBtRequestMessage(piece->getIndex(), blockIndex));
     }
   };
@@ -70,8 +70,8 @@ public:
 
   class SortMockBtRequestMessage {
   public:
-    bool operator()(const SharedHandle<MockBtRequestMessage>& a,
-                    const SharedHandle<MockBtRequestMessage>& b) {
+    bool operator()(const std::shared_ptr<MockBtRequestMessage>& a,
+                    const std::shared_ptr<MockBtRequestMessage>& b) {
       if(a->index < b->index) {
         return true;
       } else if(b->index < a->index) {
@@ -109,12 +109,12 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DefaultBtRequestFactoryTest);
 
 void DefaultBtRequestFactoryTest::testAddTargetPiece() {
   {
-    SharedHandle<Piece> piece(new Piece(0, 16*1024*10));
+    std::shared_ptr<Piece> piece(new Piece(0, 16*1024*10));
     requestFactory_->addTargetPiece(piece);
     CPPUNIT_ASSERT_EQUAL((size_t)1, requestFactory_->countTargetPiece());
   }
   {
-    SharedHandle<Piece> piece(new Piece(1, 16*1024*9));
+    std::shared_ptr<Piece> piece(new Piece(1, 16*1024*9));
     piece->completeBlock(0);
     requestFactory_->addTargetPiece(piece);
     CPPUNIT_ASSERT_EQUAL((size_t)2, requestFactory_->countTargetPiece());
@@ -123,8 +123,8 @@ void DefaultBtRequestFactoryTest::testAddTargetPiece() {
 }
 
 void DefaultBtRequestFactoryTest::testRemoveCompletedPiece() {
-  SharedHandle<Piece> piece1(new Piece(0, 16*1024));
-  SharedHandle<Piece> piece2(new Piece(1, 16*1024));
+  std::shared_ptr<Piece> piece1(new Piece(0, 16*1024));
+  std::shared_ptr<Piece> piece2(new Piece(1, 16*1024));
   piece2->setAllBlock();
   requestFactory_->addTargetPiece(piece1);
   requestFactory_->addTargetPiece(piece2);
@@ -137,61 +137,60 @@ void DefaultBtRequestFactoryTest::testRemoveCompletedPiece() {
 
 void DefaultBtRequestFactoryTest::testCreateRequestMessages() {
   int PIECE_LENGTH = 16*1024*2;
-  SharedHandle<Piece> piece1(new Piece(0, PIECE_LENGTH));
-  SharedHandle<Piece> piece2(new Piece(1, PIECE_LENGTH));
+  std::shared_ptr<Piece> piece1(new Piece(0, PIECE_LENGTH));
+  std::shared_ptr<Piece> piece2(new Piece(1, PIECE_LENGTH));
   requestFactory_->addTargetPiece(piece1);
   requestFactory_->addTargetPiece(piece2);
 
-  std::vector<SharedHandle<BtMessage> > msgs;
+  std::vector<std::shared_ptr<BtMessage> > msgs;
   requestFactory_->createRequestMessages(msgs, 3);
 
   CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
-  std::vector<SharedHandle<BtMessage> >::iterator itr = msgs.begin();
-  SharedHandle<MockBtRequestMessage> msg =
-    dynamic_pointer_cast<MockBtRequestMessage>(*itr);
+  std::vector<std::shared_ptr<BtMessage> >::iterator itr = msgs.begin();
+  auto msg = std::dynamic_pointer_cast<MockBtRequestMessage>(*itr);
   CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
   CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
   ++itr;
-  msg = dynamic_pointer_cast<MockBtRequestMessage>(*itr);
+  msg = std::dynamic_pointer_cast<MockBtRequestMessage>(*itr);
   CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
   CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
   ++itr;
-  msg = dynamic_pointer_cast<MockBtRequestMessage>(*itr);
+  msg = std::dynamic_pointer_cast<MockBtRequestMessage>(*itr);
   CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
   CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
 
   {
-    std::vector<SharedHandle<BtMessage> > msgs;
+    std::vector<std::shared_ptr<BtMessage> > msgs;
     requestFactory_->createRequestMessages(msgs, 3);
     CPPUNIT_ASSERT_EQUAL((size_t)1, msgs.size());
   }
 }
 
 void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame() {
-  SharedHandle<MockBtMessageDispatcher2> dispatcher
+  std::shared_ptr<MockBtMessageDispatcher2> dispatcher
     (new MockBtMessageDispatcher2());
 
   requestFactory_->setBtMessageDispatcher(dispatcher.get());
 
   int PIECE_LENGTH = 16*1024*2;
-  SharedHandle<Piece> piece1(new Piece(0, PIECE_LENGTH));
-  SharedHandle<Piece> piece2(new Piece(1, PIECE_LENGTH));
+  std::shared_ptr<Piece> piece1(new Piece(0, PIECE_LENGTH));
+  std::shared_ptr<Piece> piece2(new Piece(1, PIECE_LENGTH));
   requestFactory_->addTargetPiece(piece1);
   requestFactory_->addTargetPiece(piece2);
 
-  std::vector<SharedHandle<BtMessage> > msgs;
+  std::vector<std::shared_ptr<BtMessage> > msgs;
   requestFactory_->createRequestMessagesOnEndGame(msgs, 3);
 
-  std::vector<SharedHandle<MockBtRequestMessage> > mmsgs;
-  for(std::vector<SharedHandle<BtMessage> >::iterator i = msgs.begin();
+  std::vector<std::shared_ptr<MockBtRequestMessage> > mmsgs;
+  for(std::vector<std::shared_ptr<BtMessage> >::iterator i = msgs.begin();
       i != msgs.end(); ++i) {
-    mmsgs.push_back(dynamic_pointer_cast<MockBtRequestMessage>(*i));
+    mmsgs.push_back(std::dynamic_pointer_cast<MockBtRequestMessage>(*i));
   }
 
   std::sort(mmsgs.begin(), mmsgs.end(), SortMockBtRequestMessage());
 
   CPPUNIT_ASSERT_EQUAL((size_t)3, mmsgs.size());
-  std::vector<SharedHandle<MockBtRequestMessage> >::iterator itr =mmsgs.begin();
+  std::vector<std::shared_ptr<MockBtRequestMessage> >::iterator itr =mmsgs.begin();
   MockBtRequestMessage* msg = (*itr).get();
   CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
   CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
@@ -206,7 +205,7 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame() {
 }
 
 void DefaultBtRequestFactoryTest::testRemoveTargetPiece() {
-  SharedHandle<Piece> piece1(new Piece(0, 16*1024));
+  std::shared_ptr<Piece> piece1(new Piece(0, 16*1024));
 
   requestFactory_->addTargetPiece(piece1);
 
@@ -225,9 +224,9 @@ void DefaultBtRequestFactoryTest::testRemoveTargetPiece() {
 
 void DefaultBtRequestFactoryTest::testGetTargetPieceIndexes()
 {
-  SharedHandle<Piece> piece1(new Piece(1, 16*1024));
-  SharedHandle<Piece> piece3(new Piece(3, 16*1024));
-  SharedHandle<Piece> piece5(new Piece(5, 16*1024));
+  std::shared_ptr<Piece> piece1(new Piece(1, 16*1024));
+  std::shared_ptr<Piece> piece3(new Piece(3, 16*1024));
+  std::shared_ptr<Piece> piece5(new Piece(5, 16*1024));
 
   requestFactory_->addTargetPiece(piece3);
   requestFactory_->addTargetPiece(piece1);
diff --git a/test/DefaultExtensionMessageFactoryTest.cc b/test/DefaultExtensionMessageFactoryTest.cc
index 4fbdf457..82acb8a1 100644
--- a/test/DefaultExtensionMessageFactoryTest.cc
+++ b/test/DefaultExtensionMessageFactoryTest.cc
@@ -38,14 +38,14 @@ class DefaultExtensionMessageFactoryTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testCreateMessage_UTMetadataReject);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<MockPeerStorage> peerStorage_;
-  SharedHandle<Peer> peer_;
-  SharedHandle<DefaultExtensionMessageFactory> factory_;
-  SharedHandle<ExtensionMessageRegistry> registry_;
-  SharedHandle<MockBtMessageDispatcher> dispatcher_;
-  SharedHandle<MockBtMessageFactory> messageFactory_;
-  SharedHandle<DownloadContext> dctx_;
-  SharedHandle<RequestGroup> requestGroup_;
+  std::shared_ptr<MockPeerStorage> peerStorage_;
+  std::shared_ptr<Peer> peer_;
+  std::shared_ptr<DefaultExtensionMessageFactory> factory_;
+  std::shared_ptr<ExtensionMessageRegistry> registry_;
+  std::shared_ptr<MockBtMessageDispatcher> dispatcher_;
+  std::shared_ptr<MockBtMessageFactory> messageFactory_;
+  std::shared_ptr<DownloadContext> dctx_;
+  std::shared_ptr<RequestGroup> requestGroup_;
 public:
   void setUp()
   {
@@ -63,7 +63,7 @@ public:
 
     dctx_.reset(new DownloadContext());
 
-    SharedHandle<Option> option(new Option());
+    std::shared_ptr<Option> option(new Option());
     requestGroup_.reset(new RequestGroup(GroupId::create(), option));
     requestGroup_->setDownloadContext(dctx_);
 
@@ -83,9 +83,9 @@ public:
   }
 
   template<typename T>
-  SharedHandle<T> createMessage(const std::string& data)
+  std::shared_ptr<T> createMessage(const std::string& data)
   {
-    return dynamic_pointer_cast<T>
+    return std::dynamic_pointer_cast<T>
       (factory_->createMessage
        (reinterpret_cast<const unsigned char*>(data.c_str()), data.size()));
   }
@@ -123,7 +123,7 @@ void DefaultExtensionMessageFactoryTest::testCreateMessage_Handshake()
   char id[1] = { 0 };
 
   std::string data = std::string(&id[0], &id[1])+"d1:v5:aria2e";
-  SharedHandle<HandshakeExtensionMessage> m =
+  std::shared_ptr<HandshakeExtensionMessage> m =
     createMessage<HandshakeExtensionMessage>(data);
   CPPUNIT_ASSERT_EQUAL(std::string("aria2"), m->getClientVersion());
 }
@@ -148,7 +148,7 @@ void DefaultExtensionMessageFactoryTest::testCreateMessage_UTPex()
     std::string(&c3[0], &c3[6])+std::string(&c4[0], &c4[6])+
     "e";
 
-  SharedHandle<UTPexExtensionMessage> m =
+  std::shared_ptr<UTPexExtensionMessage> m =
     createMessage<UTPexExtensionMessage>(data);
   CPPUNIT_ASSERT_EQUAL(registry_->getExtensionMessageID
                        (ExtensionMessageRegistry::UT_PEX),
@@ -162,7 +162,7 @@ void DefaultExtensionMessageFactoryTest::testCreateMessage_UTMetadataRequest()
   std::string data = getExtensionMessageID
     (ExtensionMessageRegistry::UT_METADATA)+
     "d8:msg_typei0e5:piecei1ee";
-  SharedHandle<UTMetadataRequestExtensionMessage> m =
+  std::shared_ptr<UTMetadataRequestExtensionMessage> m =
     createMessage<UTMetadataRequestExtensionMessage>(data);
   CPPUNIT_ASSERT_EQUAL((size_t)1, m->getIndex());
 }
@@ -174,7 +174,7 @@ void DefaultExtensionMessageFactoryTest::testCreateMessage_UTMetadataData()
   std::string data = getExtensionMessageID
     (ExtensionMessageRegistry::UT_METADATA)+
     "d8:msg_typei1e5:piecei1e10:total_sizei300ee0000000000";
-  SharedHandle<UTMetadataDataExtensionMessage> m =
+  std::shared_ptr<UTMetadataDataExtensionMessage> m =
     createMessage<UTMetadataDataExtensionMessage>(data);
   CPPUNIT_ASSERT_EQUAL((size_t)1, m->getIndex());
   CPPUNIT_ASSERT_EQUAL((size_t)300, m->getTotalSize());
@@ -188,7 +188,7 @@ void DefaultExtensionMessageFactoryTest::testCreateMessage_UTMetadataReject()
   std::string data = getExtensionMessageID
     (ExtensionMessageRegistry::UT_METADATA)+
     "d8:msg_typei2e5:piecei1ee";
-  SharedHandle<UTMetadataRejectExtensionMessage> m =
+  std::shared_ptr<UTMetadataRejectExtensionMessage> m =
     createMessage<UTMetadataRejectExtensionMessage>(data);
   CPPUNIT_ASSERT_EQUAL((size_t)1, m->getIndex());
 }
diff --git a/test/DefaultPeerStorageTest.cc b/test/DefaultPeerStorageTest.cc
index acd13951..1abe81a3 100644
--- a/test/DefaultPeerStorageTest.cc
+++ b/test/DefaultPeerStorageTest.cc
@@ -26,7 +26,7 @@ class DefaultPeerStorageTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testAddBadPeer);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<BtRuntime> btRuntime;
+  std::shared_ptr<BtRuntime> btRuntime;
   Option* option;
 public:
   void setUp() {
@@ -57,11 +57,11 @@ void DefaultPeerStorageTest::testCountAllPeer()
 
   CPPUNIT_ASSERT_EQUAL((size_t)0, ps.countAllPeer());
   for(int i = 0; i < 2; ++i) {
-    SharedHandle<Peer> peer(new Peer("192.168.0.1", 6889+i));
+    std::shared_ptr<Peer> peer(new Peer("192.168.0.1", 6889+i));
     ps.addPeer(peer);
   }
   CPPUNIT_ASSERT_EQUAL((size_t)2, ps.countAllPeer());
-  SharedHandle<Peer> peer = ps.checkoutPeer(1);
+  std::shared_ptr<Peer> peer = ps.checkoutPeer(1);
   CPPUNIT_ASSERT(peer);
   CPPUNIT_ASSERT_EQUAL((size_t)2, ps.countAllPeer());
   ps.returnPeer(peer);
@@ -72,9 +72,9 @@ void DefaultPeerStorageTest::testDeleteUnusedPeer()
 {
   DefaultPeerStorage ps;
 
-  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));
+  std::shared_ptr<Peer> peer1(new Peer("192.168.0.1", 6889));
+  std::shared_ptr<Peer> peer2(new Peer("192.168.0.2", 6889));
+  std::shared_ptr<Peer> peer3(new Peer("192.168.0.3", 6889));
 
   CPPUNIT_ASSERT(ps.addPeer(peer1));
   CPPUNIT_ASSERT(ps.addPeer(peer2));
@@ -93,13 +93,13 @@ void DefaultPeerStorageTest::testDeleteUnusedPeer()
 void DefaultPeerStorageTest::testAddPeer()
 {
   DefaultPeerStorage ps;
-  SharedHandle<BtRuntime> btRuntime(new BtRuntime());
+  std::shared_ptr<BtRuntime> btRuntime(new BtRuntime());
   ps.setMaxPeerListSize(2);
   ps.setBtRuntime(btRuntime);
 
-  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));
+  std::shared_ptr<Peer> peer1(new Peer("192.168.0.1", 6889));
+  std::shared_ptr<Peer> peer2(new Peer("192.168.0.2", 6889));
+  std::shared_ptr<Peer> peer3(new Peer("192.168.0.3", 6889));
 
   CPPUNIT_ASSERT(ps.addPeer(peer1));
   CPPUNIT_ASSERT(ps.addPeer(peer2));
@@ -124,7 +124,7 @@ void DefaultPeerStorageTest::testAddPeer()
 void DefaultPeerStorageTest::testIsPeerAvailable() {
   DefaultPeerStorage ps;
   ps.setBtRuntime(btRuntime);
-  SharedHandle<Peer> peer1(new Peer("192.168.0.1", 6889));
+  std::shared_ptr<Peer> peer1(new Peer("192.168.0.1", 6889));
 
   CPPUNIT_ASSERT(!ps.isPeerAvailable());
   ps.addPeer(peer1);
@@ -136,17 +136,17 @@ void DefaultPeerStorageTest::testIsPeerAvailable() {
 void DefaultPeerStorageTest::testCheckoutPeer()
 {
   DefaultPeerStorage ps;
-  SharedHandle<Peer> peers[] = {
-    SharedHandle<Peer>(new Peer("192.168.0.1", 1000)),
-    SharedHandle<Peer>(new Peer("192.168.0.2", 1000)),
-    SharedHandle<Peer>(new Peer("192.168.0.3", 1000))
+  std::shared_ptr<Peer> peers[] = {
+    std::shared_ptr<Peer>(new Peer("192.168.0.1", 1000)),
+    std::shared_ptr<Peer>(new Peer("192.168.0.2", 1000)),
+    std::shared_ptr<Peer>(new Peer("192.168.0.3", 1000))
   };
   int len = A2_ARRAY_LEN(peers);
   for(int i = 0; i < len; ++i) {
     ps.addPeer(peers[i]);
   }
   for(int i = 0; i < len; ++i) {
-    SharedHandle<Peer> peer = ps.checkoutPeer(i+1);
+    std::shared_ptr<Peer> peer = ps.checkoutPeer(i+1);
     CPPUNIT_ASSERT_EQUAL(peers[len-i-1]->getIPAddress(), peer->getIPAddress());
   }
   CPPUNIT_ASSERT(!ps.checkoutPeer(len+1));
@@ -156,11 +156,11 @@ void DefaultPeerStorageTest::testReturnPeer()
 {
   DefaultPeerStorage ps;
 
-  SharedHandle<Peer> peer1(new Peer("192.168.0.1", 0));
+  std::shared_ptr<Peer> peer1(new Peer("192.168.0.1", 0));
   peer1->allocateSessionResource(1024*1024, 1024*1024*10);
-  SharedHandle<Peer> peer2(new Peer("192.168.0.2", 6889));
+  std::shared_ptr<Peer> peer2(new Peer("192.168.0.2", 6889));
   peer2->allocateSessionResource(1024*1024, 1024*1024*10);
-  SharedHandle<Peer> peer3(new Peer("192.168.0.1", 6889));
+  std::shared_ptr<Peer> peer3(new Peer("192.168.0.1", 6889));
   peer2->setDisconnectedGracefully(true);
   ps.addPeer(peer1);
   ps.addPeer(peer2);
diff --git a/test/DefaultPieceStorageTest.cc b/test/DefaultPieceStorageTest.cc
index 45bc1155..dc6c4879 100644
--- a/test/DefaultPieceStorageTest.cc
+++ b/test/DefaultPieceStorageTest.cc
@@ -41,10 +41,10 @@ class DefaultPieceStorageTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testGetNextUsedIndex);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<DownloadContext> dctx_;
-  SharedHandle<Peer> peer;
-  SharedHandle<Option> option_;
-  SharedHandle<PieceSelector> pieceSelector_;
+  std::shared_ptr<DownloadContext> dctx_;
+  std::shared_ptr<Peer> peer;
+  std::shared_ptr<Option> option_;
+  std::shared_ptr<PieceSelector> pieceSelector_;
 public:
   void setUp() {
     option_.reset(new Option());
@@ -90,7 +90,7 @@ void DefaultPieceStorageTest::testGetMissingPiece() {
   pss.setPieceSelector(pieceSelector_);
   peer->setAllBitfield();
 
-  SharedHandle<Piece> piece = pss.getMissingPiece(peer, 1);
+  std::shared_ptr<Piece> piece = pss.getMissingPiece(peer, 1);
   CPPUNIT_ASSERT_EQUAL(std::string("piece: index=0, length=128"),
                        piece->toString());
   CPPUNIT_ASSERT(piece->usedBy(1));
@@ -108,7 +108,7 @@ void DefaultPieceStorageTest::testGetMissingPiece_many() {
   DefaultPieceStorage pss(dctx_, option_.get());
   pss.setPieceSelector(pieceSelector_);
   peer->setAllBitfield();
-  std::vector<SharedHandle<Piece> > pieces;
+  std::vector<std::shared_ptr<Piece> > pieces;
   pss.getMissingPiece(pieces, 2, peer, 1);
   CPPUNIT_ASSERT_EQUAL((size_t)2, pieces.size());
   CPPUNIT_ASSERT_EQUAL(std::string("piece: index=0, length=128"),
@@ -134,7 +134,7 @@ void DefaultPieceStorageTest::testGetMissingPiece_excludedIndexes()
   std::vector<size_t> excludedIndexes;
   excludedIndexes.push_back(1);
 
-  SharedHandle<Piece> piece = pss.getMissingPiece(peer, excludedIndexes, 1);
+  std::shared_ptr<Piece> piece = pss.getMissingPiece(peer, excludedIndexes, 1);
   CPPUNIT_ASSERT_EQUAL(std::string("piece: index=0, length=128"),
                        piece->toString());
 
@@ -152,7 +152,7 @@ void DefaultPieceStorageTest::testGetMissingPiece_manyWithExcludedIndexes() {
   peer->setAllBitfield();
   std::vector<size_t> excludedIndexes;
   excludedIndexes.push_back(1);
-  std::vector<SharedHandle<Piece> > pieces;
+  std::vector<std::shared_ptr<Piece> > pieces;
   pss.getMissingPiece(pieces, 2, peer, excludedIndexes, 1);
   CPPUNIT_ASSERT_EQUAL((size_t)2, pieces.size());
   CPPUNIT_ASSERT_EQUAL(std::string("piece: index=0, length=128"),
@@ -173,7 +173,7 @@ void DefaultPieceStorageTest::testGetMissingFastPiece() {
   peer->setFastExtensionEnabled(true);
   peer->addPeerAllowedIndex(2);
 
-  SharedHandle<Piece> piece = pss.getMissingFastPiece(peer, 1);
+  std::shared_ptr<Piece> piece = pss.getMissingFastPiece(peer, 1);
   CPPUNIT_ASSERT_EQUAL(std::string("piece: index=2, length=128"),
                        piece->toString());
 
@@ -194,7 +194,7 @@ void DefaultPieceStorageTest::testGetMissingFastPiece_excludedIndexes()
   std::vector<size_t> excludedIndexes;
   excludedIndexes.push_back(2);
 
-  SharedHandle<Piece> piece = pss.getMissingFastPiece(peer, excludedIndexes, 1);
+  std::shared_ptr<Piece> piece = pss.getMissingFastPiece(peer, excludedIndexes, 1);
   CPPUNIT_ASSERT_EQUAL(std::string("piece: index=1, length=128"),
                        piece->toString());
 
@@ -218,7 +218,7 @@ void DefaultPieceStorageTest::testCompletePiece() {
 
   peer->setAllBitfield();
 
-  SharedHandle<Piece> piece = pss.getMissingPiece(peer, 1);
+  std::shared_ptr<Piece> piece = pss.getMissingPiece(peer, 1);
   CPPUNIT_ASSERT_EQUAL(std::string("piece: index=0, length=128"),
                        piece->toString());
 
@@ -228,7 +228,7 @@ void DefaultPieceStorageTest::testCompletePiece() {
 
   CPPUNIT_ASSERT_EQUAL((int64_t)128LL, pss.getCompletedLength());
 
-  SharedHandle<Piece> incompletePiece = pss.getMissingPiece(peer, 1);
+  std::shared_ptr<Piece> incompletePiece = pss.getMissingPiece(peer, 1);
   incompletePiece->completeBlock(0);
   CPPUNIT_ASSERT_EQUAL((int64_t)256LL, pss.getCompletedLength());
 }
@@ -236,7 +236,7 @@ void DefaultPieceStorageTest::testCompletePiece() {
 void DefaultPieceStorageTest::testGetPiece() {
   DefaultPieceStorage pss(dctx_, option_.get());
 
-  SharedHandle<Piece> pieceGot = pss.getPiece(0);
+  std::shared_ptr<Piece> pieceGot = pss.getPiece(0);
   CPPUNIT_ASSERT_EQUAL((size_t)0, pieceGot->getIndex());
   CPPUNIT_ASSERT_EQUAL(128, pieceGot->getLength());
   CPPUNIT_ASSERT_EQUAL(false, pieceGot->pieceComplete());
@@ -244,10 +244,10 @@ void DefaultPieceStorageTest::testGetPiece() {
 
 void DefaultPieceStorageTest::testGetPieceInUsedPieces() {
   DefaultPieceStorage pss(dctx_, option_.get());
-  SharedHandle<Piece> piece = SharedHandle<Piece>(new Piece(0, 128));
+  std::shared_ptr<Piece> piece = std::shared_ptr<Piece>(new Piece(0, 128));
   piece->completeBlock(0);
   pss.addUsedPiece(piece);
-  SharedHandle<Piece> pieceGot = pss.getPiece(0);
+  std::shared_ptr<Piece> pieceGot = pss.getPiece(0);
   CPPUNIT_ASSERT_EQUAL((size_t)0, pieceGot->getIndex());
   CPPUNIT_ASSERT_EQUAL(128, pieceGot->getLength());
   CPPUNIT_ASSERT_EQUAL((size_t)1, pieceGot->countCompleteBlock());
@@ -255,9 +255,9 @@ void DefaultPieceStorageTest::testGetPieceInUsedPieces() {
 
 void DefaultPieceStorageTest::testGetPieceCompletedPiece() {
   DefaultPieceStorage pss(dctx_, option_.get());
-  SharedHandle<Piece> piece = SharedHandle<Piece>(new Piece(0, 128));
+  std::shared_ptr<Piece> piece = std::shared_ptr<Piece>(new Piece(0, 128));
   pss.completePiece(piece);
-  SharedHandle<Piece> pieceGot = pss.getPiece(0);
+  std::shared_ptr<Piece> pieceGot = pss.getPiece(0);
   CPPUNIT_ASSERT_EQUAL((size_t)0, pieceGot->getIndex());
   CPPUNIT_ASSERT_EQUAL(128, pieceGot->getLength());
   CPPUNIT_ASSERT_EQUAL(true, pieceGot->pieceComplete());
@@ -269,19 +269,19 @@ void DefaultPieceStorageTest::testCancelPiece()
   int64_t totalLength = 32*pieceLength; // <-- make the number of piece greater than END_GAME_PIECE_NUM
   std::deque<std::string> uris1;
   uris1.push_back("http://localhost/src/file1.txt");
-  SharedHandle<FileEntry> file1(new FileEntry("src/file1.txt", totalLength, 0 /*, uris1*/));
+  std::shared_ptr<FileEntry> file1(new FileEntry("src/file1.txt", totalLength, 0 /*, uris1*/));
 
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(pieceLength, totalLength, "src/file1.txt"));
 
-  SharedHandle<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, option_.get()));
+  std::shared_ptr<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, option_.get()));
 
-  SharedHandle<Piece> p = ps->getMissingPiece(0, 1);
+  std::shared_ptr<Piece> p = ps->getMissingPiece(0, 1);
   p->completeBlock(0);
 
   ps->cancelPiece(p, 1);
 
-  SharedHandle<Piece> p2 = ps->getMissingPiece(0, 2);
+  std::shared_ptr<Piece> p2 = ps->getMissingPiece(0, 2);
 
   CPPUNIT_ASSERT(p2->hasBlock(0));
   CPPUNIT_ASSERT(p2->usedBy(2));
@@ -292,7 +292,7 @@ void DefaultPieceStorageTest::testMarkPiecesDone()
 {
   size_t pieceLength = 256*1024;
   int64_t totalLength = 4*1024*1024;
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(pieceLength, totalLength));
 
   DefaultPieceStorage ps(dctx, option_.get());
@@ -319,7 +319,7 @@ void DefaultPieceStorageTest::testMarkPiecesDone()
 
 void DefaultPieceStorageTest::testGetCompletedLength()
 {
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(1024*1024, 256*1024*1024));
 
   DefaultPieceStorage ps(dctx, option_.get());
@@ -329,9 +329,9 @@ void DefaultPieceStorageTest::testGetCompletedLength()
   ps.markPiecesDone(250*1024*1024);
   CPPUNIT_ASSERT_EQUAL((int64_t)250*1024*1024, ps.getCompletedLength());
 
-  std::vector<SharedHandle<Piece> > inFlightPieces;
+  std::vector<std::shared_ptr<Piece> > inFlightPieces;
   for(int i = 0; i < 2; ++i) {
-    SharedHandle<Piece> p(new Piece(250+i, 1024*1024));
+    std::shared_ptr<Piece> p(new Piece(250+i, 1024*1024));
     for(int j = 0; j < 32; ++j) {
       p->completeBlock(j);
     }
@@ -350,27 +350,27 @@ void DefaultPieceStorageTest::testGetCompletedLength()
 void DefaultPieceStorageTest::testGetFilteredCompletedLength()
 {
   const size_t pieceLength = 1024*1024;
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   dctx->setPieceLength(pieceLength);
-  SharedHandle<FileEntry> files[] = {
-    SharedHandle<FileEntry>(new FileEntry("foo", 2*pieceLength, 0)),
-    SharedHandle<FileEntry>(new FileEntry("bar", 4*pieceLength, 2*pieceLength))
+  std::shared_ptr<FileEntry> files[] = {
+    std::shared_ptr<FileEntry>(new FileEntry("foo", 2*pieceLength, 0)),
+    std::shared_ptr<FileEntry>(new FileEntry("bar", 4*pieceLength, 2*pieceLength))
   };
   files[1]->setRequested(false);
   dctx->setFileEntries(&files[0], &files[2]);
 
   DefaultPieceStorage ps(dctx, option_.get());
-  std::vector<SharedHandle<Piece> > inflightPieces(2);
-  inflightPieces[0] = SharedHandle<Piece>(new Piece(1, pieceLength));
+  std::vector<std::shared_ptr<Piece> > inflightPieces(2);
+  inflightPieces[0] = std::shared_ptr<Piece>(new Piece(1, pieceLength));
   inflightPieces[0]->completeBlock(0);
-  inflightPieces[1] = SharedHandle<Piece>(new Piece(2, pieceLength));
+  inflightPieces[1] = std::shared_ptr<Piece>(new Piece(2, pieceLength));
   inflightPieces[1]->completeBlock(1);
   inflightPieces[1]->completeBlock(2);
 
   ps.addInFlightPiece(inflightPieces);
   ps.setupFileFilter();
 
-  SharedHandle<Piece> piece = ps.getMissingPiece(0, 1);
+  std::shared_ptr<Piece> piece = ps.getMissingPiece(0, 1);
   ps.completePiece(piece);
 
   CPPUNIT_ASSERT_EQUAL((int64_t)pieceLength+16*1024,
@@ -381,7 +381,7 @@ void DefaultPieceStorageTest::testGetNextUsedIndex()
 {
   DefaultPieceStorage pss(dctx_, option_.get());
   CPPUNIT_ASSERT_EQUAL((size_t)3, pss.getNextUsedIndex(0));
-  SharedHandle<Piece> piece = pss.getMissingPiece(2, 1);
+  std::shared_ptr<Piece> piece = pss.getMissingPiece(2, 1);
   CPPUNIT_ASSERT_EQUAL((size_t)2, pss.getNextUsedIndex(0));
   pss.completePiece(piece);
   CPPUNIT_ASSERT_EQUAL((size_t)2, pss.getNextUsedIndex(0));
diff --git a/test/DirectDiskAdaptorTest.cc b/test/DirectDiskAdaptorTest.cc
index 3040a656..8e65dadc 100644
--- a/test/DirectDiskAdaptorTest.cc
+++ b/test/DirectDiskAdaptorTest.cc
@@ -33,17 +33,17 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DirectDiskAdaptorTest);
 void DirectDiskAdaptorTest::testCutTrailingGarbage()
 {
   std::string dir = A2_TEST_OUT_DIR;
-  SharedHandle<FileEntry> entry
+  std::shared_ptr<FileEntry> entry
     (new FileEntry(dir+"/aria2_DirectDiskAdaptorTest_testCutTrailingGarbage",
                    256, 0));
   createFile(entry->getPath(), entry->getLength()+100);
 
-  std::vector<SharedHandle<FileEntry> > fileEntries;
+  std::vector<std::shared_ptr<FileEntry> > fileEntries;
   fileEntries.push_back(entry);
 
   DirectDiskAdaptor adaptor;
   adaptor.setDiskWriter
-    (SharedHandle<DiskWriter>(new DefaultDiskWriter(entry->getPath())));
+    (std::shared_ptr<DiskWriter>(new DefaultDiskWriter(entry->getPath())));
   adaptor.setTotalLength(entry->getLength());
   adaptor.setFileEntries(fileEntries.begin(), fileEntries.end());
   adaptor.openFile();
@@ -56,8 +56,8 @@ void DirectDiskAdaptorTest::testCutTrailingGarbage()
 
 void DirectDiskAdaptorTest::testWriteCache()
 {
-  SharedHandle<DirectDiskAdaptor> adaptor(new DirectDiskAdaptor());
-  SharedHandle<ByteArrayDiskWriter> dw(new ByteArrayDiskWriter());
+  std::shared_ptr<DirectDiskAdaptor> adaptor(new DirectDiskAdaptor());
+  std::shared_ptr<ByteArrayDiskWriter> dw(new ByteArrayDiskWriter());
   adaptor->setDiskWriter(dw);
   WrDiskCacheEntry cache(adaptor);
   std::string data1(4096, '1'), data2(4094, '2');
diff --git a/test/DownloadContextTest.cc b/test/DownloadContextTest.cc
index 7d1a6a21..306bfbda 100644
--- a/test/DownloadContextTest.cc
+++ b/test/DownloadContextTest.cc
@@ -33,13 +33,13 @@ void DownloadContextTest::testFindFileEntryByOffset()
 
   CPPUNIT_ASSERT(!ctx.findFileEntryByOffset(0));
 
-  const SharedHandle<FileEntry> fileEntries[] =
-    { SharedHandle<FileEntry>(new FileEntry("file1",1000,0)),
-      SharedHandle<FileEntry>(new FileEntry("file2",0,1000)),
-      SharedHandle<FileEntry>(new FileEntry("file3",0,1000)),
-      SharedHandle<FileEntry>(new FileEntry("file4",2000,1000)),
-      SharedHandle<FileEntry>(new FileEntry("file5",3000,3000)),
-      SharedHandle<FileEntry>(new FileEntry("file6",0,6000))
+  const std::shared_ptr<FileEntry> fileEntries[] =
+    { std::shared_ptr<FileEntry>(new FileEntry("file1",1000,0)),
+      std::shared_ptr<FileEntry>(new FileEntry("file2",0,1000)),
+      std::shared_ptr<FileEntry>(new FileEntry("file3",0,1000)),
+      std::shared_ptr<FileEntry>(new FileEntry("file4",2000,1000)),
+      std::shared_ptr<FileEntry>(new FileEntry("file5",3000,3000)),
+      std::shared_ptr<FileEntry>(new FileEntry("file6",0,6000))
     };
   ctx.setFileEntries(vbegin(fileEntries), vend(fileEntries));
 
@@ -78,16 +78,16 @@ void DownloadContextTest::testGetBasePath()
 void DownloadContextTest::testSetFileFilter()
 {
   DownloadContext ctx;
-  std::vector<SharedHandle<FileEntry> > files;
+  std::vector<std::shared_ptr<FileEntry> > files;
   for(int i = 0; i < 10; ++i) {
-    files.push_back(SharedHandle<FileEntry>(new FileEntry("file", 1, i)));
+    files.push_back(std::shared_ptr<FileEntry>(new FileEntry("file", 1, i)));
   }
   ctx.setFileEntries(files.begin(), files.end());
   SegList<int> sgl;
   util::parseIntSegments(sgl, "6-8,2-4");
   sgl.normalize();
   ctx.setFileFilter(sgl);
-  const std::vector<SharedHandle<FileEntry> >& res = ctx.getFileEntries();
+  const std::vector<std::shared_ptr<FileEntry> >& res = ctx.getFileEntries();
   CPPUNIT_ASSERT(!res[0]->isRequested());
   CPPUNIT_ASSERT(res[1]->isRequested());
   CPPUNIT_ASSERT(res[2]->isRequested());
diff --git a/test/DownloadHandlerFactoryTest.cc b/test/DownloadHandlerFactoryTest.cc
index 56dfcb16..ae3f2550 100644
--- a/test/DownloadHandlerFactoryTest.cc
+++ b/test/DownloadHandlerFactoryTest.cc
@@ -25,7 +25,7 @@ class DownloadHandlerFactoryTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<Option> option_;
+  std::shared_ptr<Option> option_;
 public:
   void setUp()
   {
@@ -50,11 +50,11 @@ CPPUNIT_TEST_SUITE_REGISTRATION( DownloadHandlerFactoryTest );
 
 void DownloadHandlerFactoryTest::testGetMetalinkPreDownloadHandler_extension()
 {
-  SharedHandle<DownloadContext> dctx(new DownloadContext(0, 0, "test.metalink"));
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext(0, 0, "test.metalink"));
   RequestGroup rg(GroupId::create(), option_);
   rg.setDownloadContext(dctx);
 
-  SharedHandle<PreDownloadHandler> handler = DownloadHandlerFactory::getMetalinkPreDownloadHandler();
+  std::shared_ptr<PreDownloadHandler> handler = DownloadHandlerFactory::getMetalinkPreDownloadHandler();
 
   CPPUNIT_ASSERT(handler->canHandle(&rg));
 
@@ -64,12 +64,12 @@ void DownloadHandlerFactoryTest::testGetMetalinkPreDownloadHandler_extension()
 
 void DownloadHandlerFactoryTest::testGetMetalinkPreDownloadHandler_contentType()
 {
-  SharedHandle<DownloadContext> dctx(new DownloadContext(0, 0, "test"));
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext(0, 0, "test"));
   dctx->getFirstFileEntry()->setContentType("application/metalink+xml");
   RequestGroup rg(GroupId::create(), option_);
   rg.setDownloadContext(dctx);
 
-  SharedHandle<PreDownloadHandler> handler = DownloadHandlerFactory::getMetalinkPreDownloadHandler();
+  std::shared_ptr<PreDownloadHandler> handler = DownloadHandlerFactory::getMetalinkPreDownloadHandler();
 
   CPPUNIT_ASSERT(handler->canHandle(&rg));
 
@@ -83,12 +83,12 @@ void DownloadHandlerFactoryTest::testGetMetalinkPreDownloadHandler_contentType()
 
 void DownloadHandlerFactoryTest::testGetBtPreDownloadHandler_extension()
 {
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(0, 0, A2_TEST_DIR"/test.torrent"));
   RequestGroup rg(GroupId::create(), option_);
   rg.setDownloadContext(dctx);
 
-  SharedHandle<PreDownloadHandler> handler = DownloadHandlerFactory::getBtPreDownloadHandler();
+  std::shared_ptr<PreDownloadHandler> handler = DownloadHandlerFactory::getBtPreDownloadHandler();
 
   CPPUNIT_ASSERT(handler->canHandle(&rg));
 
@@ -98,12 +98,12 @@ void DownloadHandlerFactoryTest::testGetBtPreDownloadHandler_extension()
 
 void DownloadHandlerFactoryTest::testGetBtPreDownloadHandler_contentType()
 {
-  SharedHandle<DownloadContext> dctx(new DownloadContext(0, 0, "test"));
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext(0, 0, "test"));
   dctx->getFirstFileEntry()->setContentType("application/x-bittorrent");
   RequestGroup rg(GroupId::create(), option_);
   rg.setDownloadContext(dctx);
 
-  SharedHandle<PreDownloadHandler> handler = DownloadHandlerFactory::getBtPreDownloadHandler();
+  std::shared_ptr<PreDownloadHandler> handler = DownloadHandlerFactory::getBtPreDownloadHandler();
 
   CPPUNIT_ASSERT(handler->canHandle(&rg));
 
diff --git a/test/DownloadHelperTest.cc b/test/DownloadHelperTest.cc
index fc2e3fb0..8503d330 100644
--- a/test/DownloadHelperTest.cc
+++ b/test/DownloadHelperTest.cc
@@ -39,7 +39,7 @@ class DownloadHelperTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<Option> option_;
+  std::shared_ptr<Option> option_;
 public:
   void setUp()
   {
@@ -79,10 +79,10 @@ void DownloadHelperTest::testCreateRequestGroupForUri()
   option_->put(PREF_DIR, "/tmp");
   option_->put(PREF_OUT, "file.out");
   {
-    std::vector<SharedHandle<RequestGroup> > result;
+    std::vector<std::shared_ptr<RequestGroup> > result;
     createRequestGroupForUri(result, option_, uris);
     CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
-    SharedHandle<RequestGroup> group = result[0];
+    std::shared_ptr<RequestGroup> group = result[0];
     std::vector<std::string> xuris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(xuris);
     CPPUNIT_ASSERT_EQUAL((size_t)6, xuris.size());
@@ -90,15 +90,15 @@ void DownloadHelperTest::testCreateRequestGroupForUri()
       CPPUNIT_ASSERT_EQUAL(array[i%3], xuris[i]);
     }
     CPPUNIT_ASSERT_EQUAL(7, group->getNumConcurrentCommand());
-    SharedHandle<DownloadContext> ctx = group->getDownloadContext();
+    std::shared_ptr<DownloadContext> ctx = group->getDownloadContext();
     CPPUNIT_ASSERT_EQUAL(std::string("/tmp/file.out"), ctx->getBasePath());
   }
   option_->put(PREF_SPLIT, "5");
   {
-    std::vector<SharedHandle<RequestGroup> > result;
+    std::vector<std::shared_ptr<RequestGroup> > result;
     createRequestGroupForUri(result, option_, uris);
     CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
-    SharedHandle<RequestGroup> group = result[0];
+    std::shared_ptr<RequestGroup> group = result[0];
     std::vector<std::string> xuris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(xuris);
     CPPUNIT_ASSERT_EQUAL((size_t)5, xuris.size());
@@ -108,10 +108,10 @@ void DownloadHelperTest::testCreateRequestGroupForUri()
   }
   option_->put(PREF_SPLIT, "2");
   {
-    std::vector<SharedHandle<RequestGroup> > result;
+    std::vector<std::shared_ptr<RequestGroup> > result;
     createRequestGroupForUri(result, option_, uris);
     CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
-    SharedHandle<RequestGroup> group = result[0];
+    std::shared_ptr<RequestGroup> group = result[0];
     std::vector<std::string> xuris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(xuris);
     CPPUNIT_ASSERT_EQUAL((size_t)3, xuris.size());
@@ -121,11 +121,11 @@ void DownloadHelperTest::testCreateRequestGroupForUri()
   }
   option_->put(PREF_FORCE_SEQUENTIAL, A2_V_TRUE);
   {
-    std::vector<SharedHandle<RequestGroup> > result;
+    std::vector<std::shared_ptr<RequestGroup> > result;
     createRequestGroupForUri(result, option_, uris);
     CPPUNIT_ASSERT_EQUAL((size_t)3, result.size());
     // for alpha server
-    SharedHandle<RequestGroup> alphaGroup = result[0];
+    std::shared_ptr<RequestGroup> alphaGroup = result[0];
     std::vector<std::string> alphaURIs;
     alphaGroup->getDownloadContext()->getFirstFileEntry()->getUris(alphaURIs);
     CPPUNIT_ASSERT_EQUAL((size_t)2, alphaURIs.size());
@@ -133,7 +133,7 @@ void DownloadHelperTest::testCreateRequestGroupForUri()
       CPPUNIT_ASSERT_EQUAL(array[0], alphaURIs[i]);
     }
     CPPUNIT_ASSERT_EQUAL(2, alphaGroup->getNumConcurrentCommand());
-    SharedHandle<DownloadContext> alphaCtx = alphaGroup->getDownloadContext();
+    std::shared_ptr<DownloadContext> alphaCtx = alphaGroup->getDownloadContext();
     // See filename is not assigned yet
     CPPUNIT_ASSERT_EQUAL(std::string(""), alphaCtx->getBasePath());
   }
@@ -152,12 +152,12 @@ void DownloadHelperTest::testCreateRequestGroupForUri_parameterized()
   option_->put(PREF_OUT, "file.out");
   option_->put(PREF_PARAMETERIZED_URI, A2_V_TRUE);
   {
-    std::vector<SharedHandle<RequestGroup> > result;
+    std::vector<std::shared_ptr<RequestGroup> > result;
 
     createRequestGroupForUri(result, option_, uris);
 
     CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
-    SharedHandle<RequestGroup> group = result[0];
+    std::shared_ptr<RequestGroup> group = result[0];
     std::vector<std::string> uris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)3, uris.size());
@@ -167,7 +167,7 @@ void DownloadHelperTest::testCreateRequestGroupForUri_parameterized()
     CPPUNIT_ASSERT_EQUAL(std::string("http://charlie/file"), uris[2]);
 
     CPPUNIT_ASSERT_EQUAL(3, group->getNumConcurrentCommand());
-    SharedHandle<DownloadContext> ctx = group->getDownloadContext();
+    std::shared_ptr<DownloadContext> ctx = group->getDownloadContext();
     CPPUNIT_ASSERT_EQUAL(std::string("/tmp/file.out"), ctx->getBasePath());
   }
 }
@@ -187,12 +187,12 @@ void DownloadHelperTest::testCreateRequestGroupForUri_BitTorrent()
   option_->put(PREF_DIR, "/tmp");
   option_->put(PREF_OUT, "file.out");
   {
-    std::vector<SharedHandle<RequestGroup> > result;
+    std::vector<std::shared_ptr<RequestGroup> > result;
 
     createRequestGroupForUri(result, option_, uris);
 
     CPPUNIT_ASSERT_EQUAL((size_t)2, result.size());
-    SharedHandle<RequestGroup> group = result[0];
+    std::shared_ptr<RequestGroup> group = result[0];
     std::vector<std::string> xuris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(xuris);
     CPPUNIT_ASSERT_EQUAL((size_t)3, xuris.size());
@@ -202,16 +202,16 @@ void DownloadHelperTest::testCreateRequestGroupForUri_BitTorrent()
     CPPUNIT_ASSERT_EQUAL(array[3], xuris[2]);
 
     CPPUNIT_ASSERT_EQUAL(3, group->getNumConcurrentCommand());
-    SharedHandle<DownloadContext> ctx = group->getDownloadContext();
+    std::shared_ptr<DownloadContext> ctx = group->getDownloadContext();
     CPPUNIT_ASSERT_EQUAL(std::string("/tmp/file.out"),
                          ctx->getBasePath());
 
-    SharedHandle<RequestGroup> torrentGroup = result[1];
+    std::shared_ptr<RequestGroup> torrentGroup = result[1];
     std::vector<std::string> auxURIs;
     torrentGroup->getDownloadContext()->getFirstFileEntry()->getUris(auxURIs);
     CPPUNIT_ASSERT(auxURIs.empty());
     CPPUNIT_ASSERT_EQUAL(3, torrentGroup->getNumConcurrentCommand());
-    SharedHandle<DownloadContext> btctx = torrentGroup->getDownloadContext();
+    std::shared_ptr<DownloadContext> btctx = torrentGroup->getDownloadContext();
     CPPUNIT_ASSERT_EQUAL(std::string("/tmp/aria2-test"),
                          btctx->getBasePath());
   }
@@ -233,7 +233,7 @@ void DownloadHelperTest::testCreateRequestGroupForUri_Metalink()
   option_->put(PREF_DIR, "/tmp");
   option_->put(PREF_OUT, "file.out");
   {
-    std::vector<SharedHandle<RequestGroup> > result;
+    std::vector<std::shared_ptr<RequestGroup> > result;
 
     createRequestGroupForUri(result, option_, uris);
 
@@ -245,7 +245,7 @@ void DownloadHelperTest::testCreateRequestGroupForUri_Metalink()
     CPPUNIT_ASSERT_EQUAL((size_t)6, result.size());
 #endif // !ENABLE_BITTORRENT
 
-    SharedHandle<RequestGroup> group = result[0];
+    std::shared_ptr<RequestGroup> group = result[0];
     std::vector<std::string> xuris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(xuris);
     CPPUNIT_ASSERT_EQUAL((size_t)3, xuris.size());
@@ -253,19 +253,19 @@ void DownloadHelperTest::testCreateRequestGroupForUri_Metalink()
       CPPUNIT_ASSERT_EQUAL(array[i], xuris[i]);
     }
     CPPUNIT_ASSERT_EQUAL(2, group->getNumConcurrentCommand());
-    SharedHandle<DownloadContext> ctx = group->getDownloadContext();
+    std::shared_ptr<DownloadContext> ctx = group->getDownloadContext();
     CPPUNIT_ASSERT_EQUAL(std::string("/tmp/file.out"),
                          ctx->getBasePath());
 
-    SharedHandle<RequestGroup> aria2052Group = result[1];
+    std::shared_ptr<RequestGroup> aria2052Group = result[1];
     CPPUNIT_ASSERT_EQUAL(1, // because of maxconnections attribute
                          aria2052Group->getNumConcurrentCommand());
-    SharedHandle<DownloadContext> aria2052Ctx =
+    std::shared_ptr<DownloadContext> aria2052Ctx =
       aria2052Group->getDownloadContext();
     CPPUNIT_ASSERT_EQUAL(std::string("/tmp/aria2-0.5.2.tar.bz2"),
                          aria2052Ctx->getBasePath());
 
-    SharedHandle<RequestGroup> aria2051Group = result[2];
+    std::shared_ptr<RequestGroup> aria2051Group = result[2];
     CPPUNIT_ASSERT_EQUAL(2, aria2051Group->getNumConcurrentCommand());
   }
 }
@@ -279,25 +279,25 @@ void DownloadHelperTest::testCreateRequestGroupForUriList()
   option_->put(PREF_DIR, "/tmp");
   option_->put(PREF_OUT, "file.out");
 
-  std::vector<SharedHandle<RequestGroup> > result;
+  std::vector<std::shared_ptr<RequestGroup> > result;
 
   createRequestGroupForUriList(result, option_);
 
   CPPUNIT_ASSERT_EQUAL((size_t)2, result.size());
 
-  SharedHandle<RequestGroup> fileGroup = result[0];
+  std::shared_ptr<RequestGroup> fileGroup = result[0];
   std::vector<std::string> fileURIs;
   fileGroup->getDownloadContext()->getFirstFileEntry()->getUris(fileURIs);
   CPPUNIT_ASSERT_EQUAL(std::string("http://alpha/file"), fileURIs[0]);
   CPPUNIT_ASSERT_EQUAL(std::string("http://bravo/file"), fileURIs[1]);
   CPPUNIT_ASSERT_EQUAL(std::string("http://charlie/file"), fileURIs[2]);
   CPPUNIT_ASSERT_EQUAL(3, fileGroup->getNumConcurrentCommand());
-  SharedHandle<DownloadContext> fileCtx = fileGroup->getDownloadContext();
+  std::shared_ptr<DownloadContext> fileCtx = fileGroup->getDownloadContext();
   CPPUNIT_ASSERT_EQUAL(std::string("/mydownloads/myfile.out"),
                        fileCtx->getBasePath());
 
-  SharedHandle<RequestGroup> fileISOGroup = result[1];
-  SharedHandle<DownloadContext> fileISOCtx = fileISOGroup->getDownloadContext();
+  std::shared_ptr<RequestGroup> fileISOGroup = result[1];
+  std::shared_ptr<DownloadContext> fileISOCtx = fileISOGroup->getDownloadContext();
   // PREF_OUT in option_ must be ignored.
   CPPUNIT_ASSERT_EQUAL(std::string(), fileISOCtx->getBasePath());
 }
@@ -319,14 +319,14 @@ void DownloadHelperTest::testCreateRequestGroupForBitTorrent()
   option_->put(PREF_OUT, "file.out");
   option_->put(PREF_BT_EXCLUDE_TRACKER, "http://tracker1");
   {
-    std::vector<SharedHandle<RequestGroup> > result;
+    std::vector<std::shared_ptr<RequestGroup> > result;
 
     createRequestGroupForBitTorrent(result, option_, auxURIs,
                                     option_->get(PREF_TORRENT_FILE));
 
     CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
 
-    SharedHandle<RequestGroup> group = result[0];
+    std::shared_ptr<RequestGroup> group = result[0];
     std::vector<std::string> uris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     // See -s option is ignored. See processRootDictionary() in
@@ -336,27 +336,27 @@ void DownloadHelperTest::testCreateRequestGroupForBitTorrent()
       CPPUNIT_ASSERT_EQUAL(array[i]+"/aria2-test/aria2/src/aria2c", uris[i]);
     }
     CPPUNIT_ASSERT_EQUAL(5, group->getNumConcurrentCommand());
-    SharedHandle<TorrentAttribute> attrs =
+    std::shared_ptr<TorrentAttribute> attrs =
       bittorrent::getTorrentAttrs(group->getDownloadContext());
     // http://tracker1 was deleted.
     CPPUNIT_ASSERT_EQUAL((size_t)2, attrs->announceList.size());
   }
   {
     // no URIs are given
-    std::vector<SharedHandle<RequestGroup> > result;
+    std::vector<std::shared_ptr<RequestGroup> > result;
     std::vector<std::string> emptyURIs;
     createRequestGroupForBitTorrent(result, option_, emptyURIs,
                                     option_->get(PREF_TORRENT_FILE));
 
     CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
-    SharedHandle<RequestGroup> group = result[0];
+    std::shared_ptr<RequestGroup> group = result[0];
     std::vector<std::string> uris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)0, uris.size());
   }
   option_->put(PREF_FORCE_SEQUENTIAL, A2_V_TRUE);
   {
-    std::vector<SharedHandle<RequestGroup> > result;
+    std::vector<std::shared_ptr<RequestGroup> > result;
 
     createRequestGroupForBitTorrent(result, option_, auxURIs,
                                     option_->get(PREF_TORRENT_FILE));
@@ -375,7 +375,7 @@ void DownloadHelperTest::testCreateRequestGroupForMetalink()
   option_->put(PREF_DIR, "/tmp");
   option_->put(PREF_OUT, "file.out");
   {
-    std::vector<SharedHandle<RequestGroup> > result;
+    std::vector<std::shared_ptr<RequestGroup> > result;
 
     createRequestGroupForMetalink(result, option_);
 
@@ -384,7 +384,7 @@ void DownloadHelperTest::testCreateRequestGroupForMetalink()
 #else // !ENABLE_BITTORRENT
     CPPUNIT_ASSERT_EQUAL((size_t)5, result.size());
 #endif // !ENABLE_BITTORRENT
-    SharedHandle<RequestGroup> group = result[0];
+    std::shared_ptr<RequestGroup> group = result[0];
     std::vector<std::string> uris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     std::sort(uris.begin(), uris.end());
diff --git a/test/FeedbackURISelectorTest.cc b/test/FeedbackURISelectorTest.cc
index 09fcc5e5..4bc29574 100644
--- a/test/FeedbackURISelectorTest.cc
+++ b/test/FeedbackURISelectorTest.cc
@@ -22,9 +22,9 @@ class FeedbackURISelectorTest:public CppUnit::TestFixture {
 private:
   FileEntry fileEntry_;
 
-  SharedHandle<ServerStatMan> ssm;
+  std::shared_ptr<ServerStatMan> ssm;
 
-  SharedHandle<FeedbackURISelector> sel;
+  std::shared_ptr<FeedbackURISelector> sel;
 
 public:
   void setUp()
@@ -68,11 +68,11 @@ void FeedbackURISelectorTest::testSelect_withoutServerStat()
 
 void FeedbackURISelectorTest::testSelect()
 {
-  SharedHandle<ServerStat> bravo(new ServerStat("bravo", "http"));
+  std::shared_ptr<ServerStat> bravo(new ServerStat("bravo", "http"));
   bravo->updateDownloadSpeed(100000);
-  SharedHandle<ServerStat> alphaFTP(new ServerStat("alpha", "ftp"));
+  std::shared_ptr<ServerStat> alphaFTP(new ServerStat("alpha", "ftp"));
   alphaFTP->updateDownloadSpeed(80000);
-  SharedHandle<ServerStat> alphaHTTP(new ServerStat("alpha", "http"));
+  std::shared_ptr<ServerStat> alphaHTTP(new ServerStat("alpha", "http"));
   alphaHTTP->updateDownloadSpeed(180000);
   alphaHTTP->setError();
   std::vector<std::pair<size_t, std::string> > usedHosts;
@@ -111,9 +111,9 @@ void FeedbackURISelectorTest::testSelect_withUsedHosts()
 
 void FeedbackURISelectorTest::testSelect_skipErrorHost()
 {
-  SharedHandle<ServerStat> alphaHTTP(new ServerStat("alpha", "http"));
+  std::shared_ptr<ServerStat> alphaHTTP(new ServerStat("alpha", "http"));
   alphaHTTP->setError();
-  SharedHandle<ServerStat> alphaFTP(new ServerStat("alpha", "ftp"));
+  std::shared_ptr<ServerStat> alphaFTP(new ServerStat("alpha", "ftp"));
   alphaFTP->setError();
   std::vector<std::pair<size_t, std::string> > usedHosts;
 
diff --git a/test/FileEntryTest.cc b/test/FileEntryTest.cc
index 2747a307..2b599013 100644
--- a/test/FileEntryTest.cc
+++ b/test/FileEntryTest.cc
@@ -44,12 +44,12 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION( FileEntryTest );
 
 namespace {
-SharedHandle<FileEntry> createFileEntry()
+std::shared_ptr<FileEntry> createFileEntry()
 {
   const char* uris[] = { "http://localhost/aria2.zip",
                          "ftp://localhost/aria2.zip",
                          "http://mirror/aria2.zip" };
-  SharedHandle<FileEntry> fileEntry(new FileEntry());
+  std::shared_ptr<FileEntry> fileEntry(new FileEntry());
   fileEntry->setUris(std::vector<std::string>(&uris[0], &uris[3]));
   return fileEntry;
 }
@@ -57,7 +57,7 @@ SharedHandle<FileEntry> createFileEntry()
 
 void FileEntryTest::testRemoveURIWhoseHostnameIs()
 {
-  SharedHandle<FileEntry> fileEntry = createFileEntry();
+  std::shared_ptr<FileEntry> fileEntry = createFileEntry();
   fileEntry->removeURIWhoseHostnameIs("localhost");
   CPPUNIT_ASSERT_EQUAL((size_t)1, fileEntry->getRemainingUris().size());
   CPPUNIT_ASSERT_EQUAL(std::string("http://mirror/aria2.zip"),
@@ -94,42 +94,42 @@ void FileEntryTest::testExtractURIResult()
 
 void FileEntryTest::testGetRequest()
 {
-  SharedHandle<FileEntry> fileEntry = createFileEntry();
-  SharedHandle<InorderURISelector> selector(new InorderURISelector());
+  std::shared_ptr<FileEntry> fileEntry = createFileEntry();
+  std::shared_ptr<InorderURISelector> selector(new InorderURISelector());
   std::vector<std::pair<size_t, std::string> > usedHosts;
-  SharedHandle<Request> req =
+  std::shared_ptr<Request> req =
     fileEntry->getRequest(selector, true, usedHosts);
   CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req->getHost());
   CPPUNIT_ASSERT_EQUAL(std::string("http"), req->getProtocol());
   fileEntry->poolRequest(req);
 
-  SharedHandle<Request> req2nd =
+  std::shared_ptr<Request> req2nd =
     fileEntry->getRequest(selector, true, usedHosts);
   CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req2nd->getHost());
   CPPUNIT_ASSERT_EQUAL(std::string("http"), req2nd->getProtocol());
 
-  SharedHandle<Request> req3rd =
+  std::shared_ptr<Request> req3rd =
     fileEntry->getRequest(selector, true, usedHosts);
   CPPUNIT_ASSERT_EQUAL(std::string("mirror"), req3rd->getHost());
   CPPUNIT_ASSERT_EQUAL(std::string("http"), req3rd->getProtocol());
 
-  SharedHandle<Request> req4th =
+  std::shared_ptr<Request> req4th =
     fileEntry->getRequest(selector, true, usedHosts);
   CPPUNIT_ASSERT(!req4th);
 
   fileEntry->setMaxConnectionPerServer(2);
 
-  SharedHandle<Request> req5th =
+  std::shared_ptr<Request> req5th =
     fileEntry->getRequest(selector, true, usedHosts);
   CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req5th->getHost());
   CPPUNIT_ASSERT_EQUAL(std::string("ftp"), req5th->getProtocol());
 
-  SharedHandle<Request> req6th =
+  std::shared_ptr<Request> req6th =
     fileEntry->getRequest(selector, true, usedHosts);
   CPPUNIT_ASSERT_EQUAL(std::string("mirror"), req6th->getHost());
   CPPUNIT_ASSERT_EQUAL(std::string("http"), req6th->getProtocol());
 
-  SharedHandle<Request> req7th =
+  std::shared_ptr<Request> req7th =
     fileEntry->getRequest(selector, true, usedHosts);
   CPPUNIT_ASSERT(!req7th);
 }
@@ -137,24 +137,24 @@ void FileEntryTest::testGetRequest()
 void FileEntryTest::testGetRequest_withoutUriReuse()
 {
   std::vector<std::pair<size_t, std::string> > usedHosts;
-  SharedHandle<FileEntry> fileEntry = createFileEntry();
+  std::shared_ptr<FileEntry> fileEntry = createFileEntry();
   fileEntry->setMaxConnectionPerServer(2);
-  SharedHandle<InorderURISelector> selector(new InorderURISelector());
-  SharedHandle<Request> req = fileEntry->getRequest(selector, false, usedHosts);
+  std::shared_ptr<InorderURISelector> selector(new InorderURISelector());
+  std::shared_ptr<Request> req = fileEntry->getRequest(selector, false, usedHosts);
   CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req->getHost());
   CPPUNIT_ASSERT_EQUAL(std::string("http"), req->getProtocol());
 
-  SharedHandle<Request> req2nd =
+  std::shared_ptr<Request> req2nd =
     fileEntry->getRequest(selector, false, usedHosts);
   CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req2nd->getHost());
   CPPUNIT_ASSERT_EQUAL(std::string("ftp"), req2nd->getProtocol());
 
-  SharedHandle<Request> req3rd =
+  std::shared_ptr<Request> req3rd =
     fileEntry->getRequest(selector, false, usedHosts);
   CPPUNIT_ASSERT_EQUAL(std::string("mirror"), req3rd->getHost());
   CPPUNIT_ASSERT_EQUAL(std::string("http"), req3rd->getProtocol());
 
-  SharedHandle<Request> req4th =
+  std::shared_ptr<Request> req4th =
     fileEntry->getRequest(selector, false, usedHosts);
   CPPUNIT_ASSERT(!req4th);
 }
@@ -162,20 +162,20 @@ void FileEntryTest::testGetRequest_withoutUriReuse()
 void FileEntryTest::testGetRequest_withUniqueProtocol()
 {
   std::vector<std::pair<size_t, std::string> > usedHosts;
-  SharedHandle<FileEntry> fileEntry = createFileEntry();
+  std::shared_ptr<FileEntry> fileEntry = createFileEntry();
   fileEntry->setUniqueProtocol(true);
-  SharedHandle<InorderURISelector> selector(new InorderURISelector());
-  SharedHandle<Request> req =
+  std::shared_ptr<InorderURISelector> selector(new InorderURISelector());
+  std::shared_ptr<Request> req =
     fileEntry->getRequest(selector, true, usedHosts);
   CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req->getHost());
   CPPUNIT_ASSERT_EQUAL(std::string("http"), req->getProtocol());
 
-  SharedHandle<Request> req2nd =
+  std::shared_ptr<Request> req2nd =
     fileEntry->getRequest(selector, true, usedHosts);
   CPPUNIT_ASSERT_EQUAL(std::string("mirror"), req2nd->getHost());
   CPPUNIT_ASSERT_EQUAL(std::string("http"), req2nd->getProtocol());
 
-  SharedHandle<Request> req3rd =
+  std::shared_ptr<Request> req3rd =
     fileEntry->getRequest(selector, true, usedHosts);
   CPPUNIT_ASSERT(!req3rd);
 
@@ -188,10 +188,10 @@ void FileEntryTest::testGetRequest_withUniqueProtocol()
 
 void FileEntryTest::testGetRequest_withReferer()
 {
-  SharedHandle<FileEntry> fileEntry = createFileEntry();
-  SharedHandle<InorderURISelector> selector(new InorderURISelector());
+  std::shared_ptr<FileEntry> fileEntry = createFileEntry();
+  std::shared_ptr<InorderURISelector> selector(new InorderURISelector());
   std::vector<std::pair<size_t, std::string> > usedHosts;
-  SharedHandle<Request> req =
+  std::shared_ptr<Request> req =
     fileEntry->getRequest(selector, true, usedHosts, "http://referer");
   CPPUNIT_ASSERT_EQUAL(std::string("http://referer"), req->getReferer());
   // URI is used as referer if "*" is given.
@@ -201,8 +201,8 @@ void FileEntryTest::testGetRequest_withReferer()
 
 void FileEntryTest::testReuseUri()
 {
-  SharedHandle<InorderURISelector> selector(new InorderURISelector());
-  SharedHandle<FileEntry> fileEntry = createFileEntry();
+  std::shared_ptr<InorderURISelector> selector(new InorderURISelector());
+  std::shared_ptr<FileEntry> fileEntry = createFileEntry();
   fileEntry->setMaxConnectionPerServer(3);
   size_t numUris = fileEntry->getRemainingUris().size();
   std::vector<std::pair<size_t, std::string> > usedHosts;
@@ -279,7 +279,7 @@ void FileEntryTest::testInsertUri()
 void FileEntryTest::testRemoveUri()
 {
   std::vector<std::pair<size_t, std::string> > usedHosts;
-  SharedHandle<InorderURISelector> selector(new InorderURISelector());
+  std::shared_ptr<InorderURISelector> selector(new InorderURISelector());
   FileEntry file;
   file.addUri("http://example.org/");
   CPPUNIT_ASSERT(file.removeUri("http://example.org/"));
@@ -287,7 +287,7 @@ void FileEntryTest::testRemoveUri()
   CPPUNIT_ASSERT(!file.removeUri("http://example.org/"));
 
   file.addUri("http://example.org/");
-  SharedHandle<Request> exampleOrgReq =
+  std::shared_ptr<Request> exampleOrgReq =
     file.getRequest(selector, true, usedHosts);
   CPPUNIT_ASSERT(!exampleOrgReq->removalRequested());
   CPPUNIT_ASSERT_EQUAL((size_t)1, file.getSpentUris().size());
@@ -311,12 +311,12 @@ void FileEntryTest::testRemoveUri()
 
 void FileEntryTest::testPutBackRequest()
 {
-  SharedHandle<FileEntry> fileEntry = createFileEntry();
-  SharedHandle<InorderURISelector> selector(new InorderURISelector());
+  std::shared_ptr<FileEntry> fileEntry = createFileEntry();
+  std::shared_ptr<InorderURISelector> selector(new InorderURISelector());
   std::vector<std::pair<size_t, std::string> > usedHosts;
-  SharedHandle<Request> req1 =
+  std::shared_ptr<Request> req1 =
     fileEntry->getRequest(selector, false, usedHosts);
-  SharedHandle<Request> req2 =
+  std::shared_ptr<Request> req2 =
     fileEntry->getRequest(selector, false, usedHosts);
   CPPUNIT_ASSERT_EQUAL((size_t)1, fileEntry->getRemainingUris().size());
   fileEntry->poolRequest(req2);
diff --git a/test/FtpConnectionTest.cc b/test/FtpConnectionTest.cc
index b8291f6e..e24cd918 100644
--- a/test/FtpConnectionTest.cc
+++ b/test/FtpConnectionTest.cc
@@ -35,13 +35,13 @@ class FtpConnectionTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testReceiveEpsvResponse);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<SocketCore> serverSocket_;
+  std::shared_ptr<SocketCore> serverSocket_;
   uint16_t listenPort_;
-  SharedHandle<SocketCore> clientSocket_;
-  SharedHandle<FtpConnection> ftp_;
-  SharedHandle<Option> option_;
-  SharedHandle<AuthConfigFactory> authConfigFactory_;
-  SharedHandle<Request> req_;
+  std::shared_ptr<SocketCore> clientSocket_;
+  std::shared_ptr<FtpConnection> ftp_;
+  std::shared_ptr<Option> option_;
+  std::shared_ptr<AuthConfigFactory> authConfigFactory_;
+  std::shared_ptr<Request> req_;
 public:
   void setUp()
   {
@@ -49,7 +49,7 @@ public:
     authConfigFactory_.reset(new AuthConfigFactory());
 
     //_ftpServerSocket.reset(new SocketCore());
-    SharedHandle<SocketCore> listenSocket(new SocketCore());
+    std::shared_ptr<SocketCore> listenSocket(new SocketCore());
     listenSocket->bind(0);
     listenSocket->beginListen();
     listenSocket->setBlockingMode();
@@ -94,7 +94,7 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION(FtpConnectionTest);
 
 namespace {
-void waitRead(const SharedHandle<SocketCore>& socket)
+void waitRead(const std::shared_ptr<SocketCore>& socket)
 {
   while(!socket->isReadable(0));
 }
diff --git a/test/GZipDecodingStreamFilterTest.cc b/test/GZipDecodingStreamFilterTest.cc
index 1f67d578..f35180a1 100644
--- a/test/GZipDecodingStreamFilterTest.cc
+++ b/test/GZipDecodingStreamFilterTest.cc
@@ -41,10 +41,10 @@ class GZipDecodingStreamFilterTest:public CppUnit::TestFixture {
     }
   };
 
-  SharedHandle<GZipDecodingStreamFilter> filter_;
-  SharedHandle<SinkStreamFilter> sinkFilter_;
-  SharedHandle<ByteArrayDiskWriter> writer_;
-  SharedHandle<MockSegment2> segment_;
+  std::shared_ptr<GZipDecodingStreamFilter> filter_;
+  std::shared_ptr<SinkStreamFilter> sinkFilter_;
+  std::shared_ptr<ByteArrayDiskWriter> writer_;
+  std::shared_ptr<MockSegment2> segment_;
 public:
   void setUp()
   {
@@ -73,7 +73,7 @@ void GZipDecodingStreamFilterTest::testTransform()
   CPPUNIT_ASSERT(filter_->finished());
 #ifdef ENABLE_MESSAGE_DIGEST
   std::string data = writer_->getString();
-  SharedHandle<MessageDigest> sha1(MessageDigest::sha1());
+  std::shared_ptr<MessageDigest> sha1(MessageDigest::sha1());
   sha1->update(data.data(), data.size());
   CPPUNIT_ASSERT_EQUAL(std::string("8b577b33c0411b2be9d4fa74c7402d54a8d21f96"),
                        util::toHex(sha1->digest()));
diff --git a/test/GroupIdTest.cc b/test/GroupIdTest.cc
index ac26bc44..fb36eaf5 100644
--- a/test/GroupIdTest.cc
+++ b/test/GroupIdTest.cc
@@ -33,7 +33,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( GroupIdTest );
 
 void GroupIdTest::testCreate()
 {
-  SharedHandle<GroupId> gid = GroupId::create();
+  std::shared_ptr<GroupId> gid = GroupId::create();
   CPPUNIT_ASSERT(gid);
   CPPUNIT_ASSERT(0 != gid->getNumericId());
   CPPUNIT_ASSERT(!GroupId::import(gid->getNumericId()));
@@ -69,12 +69,12 @@ void GroupIdTest::testToNumericId()
 void GroupIdTest::testExpandUnique()
 {
   a2_gid_t gid;
-  SharedHandle<GroupId> ids[] = {
+  std::shared_ptr<GroupId> ids[] = {
     GroupId::import(0xff80000000010000LL),
     GroupId::import(0xff80000000020001LL),
     GroupId::import(0xfff8000000030000LL)
   };
-  for(SharedHandle<GroupId>* i = vbegin(ids), *eoi = vend(ids); i != eoi;
+  for(std::shared_ptr<GroupId>* i = vbegin(ids), *eoi = vend(ids); i != eoi;
       ++i) {
     CPPUNIT_ASSERT(*i);
   }
diff --git a/test/GrowSegmentTest.cc b/test/GrowSegmentTest.cc
index 52909ee8..97b0509c 100644
--- a/test/GrowSegmentTest.cc
+++ b/test/GrowSegmentTest.cc
@@ -24,7 +24,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( GrowSegmentTest );
 
 void GrowSegmentTest::testUpdateWrittenLength()
 {
-  GrowSegment segment(SharedHandle<Piece>(new Piece()));
+  GrowSegment segment(std::shared_ptr<Piece>(new Piece()));
   segment.updateWrittenLength(32*1024);
 
   CPPUNIT_ASSERT_EQUAL((int64_t)32*1024, segment.getPositionToWrite());
@@ -34,7 +34,7 @@ void GrowSegmentTest::testUpdateWrittenLength()
 
 void GrowSegmentTest::testClear()
 {
-  GrowSegment segment(SharedHandle<Piece>(new Piece()));
+  GrowSegment segment(std::shared_ptr<Piece>(new Piece()));
   segment.updateWrittenLength(32*1024);
   CPPUNIT_ASSERT_EQUAL(32*1024, segment.getWrittenLength());
   segment.clear(0);
diff --git a/test/HandshakeExtensionMessageTest.cc b/test/HandshakeExtensionMessageTest.cc
index 26e52052..218b3e27 100644
--- a/test/HandshakeExtensionMessageTest.cc
+++ b/test/HandshakeExtensionMessageTest.cc
@@ -91,17 +91,17 @@ void HandshakeExtensionMessageTest::testToString()
 
 void HandshakeExtensionMessageTest::testDoReceivedAction()
 {
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(METADATA_PIECE_SIZE, 0));
-  SharedHandle<Option> op(new Option());
+  std::shared_ptr<Option> op(new Option());
   RequestGroup rg(GroupId::create(), op);
   rg.setDownloadContext(dctx);
 
-  SharedHandle<TorrentAttribute> attrs(new TorrentAttribute());
+  std::shared_ptr<TorrentAttribute> attrs(new TorrentAttribute());
   dctx->setAttribute(CTX_ATTR_BT, attrs);
   dctx->markTotalLengthIsUnknown();
 
-  SharedHandle<Peer> peer(new Peer("192.168.0.1", 0));
+  std::shared_ptr<Peer> peer(new Peer("192.168.0.1", 0));
   peer->allocateSessionResource(1024, 1024*1024);
   HandshakeExtensionMessage msg;
   msg.setClientVersion("aria2");
@@ -138,7 +138,7 @@ void HandshakeExtensionMessageTest::testCreate()
 {
   std::string in =
     "0d1:pi6881e1:v5:aria21:md5:a2dhti2e6:ut_pexi1ee13:metadata_sizei1024ee";
-  SharedHandle<HandshakeExtensionMessage> m
+  std::shared_ptr<HandshakeExtensionMessage> m
     (HandshakeExtensionMessage::create
      (reinterpret_cast<const unsigned char*>(in.c_str()),
       in.size()));
@@ -180,7 +180,7 @@ void HandshakeExtensionMessageTest::testCreate()
 void HandshakeExtensionMessageTest::testCreate_stringnum()
 {
   std::string in = "0d1:p4:68811:v5:aria21:md6:ut_pex1:1ee";
-  SharedHandle<HandshakeExtensionMessage> m
+  std::shared_ptr<HandshakeExtensionMessage> m
     (HandshakeExtensionMessage::create
      (reinterpret_cast<const unsigned char*>(in.c_str()),
       in.size()));
diff --git a/test/HttpHeaderProcessorTest.cc b/test/HttpHeaderProcessorTest.cc
index e9f7b389..27388e77 100644
--- a/test/HttpHeaderProcessorTest.cc
+++ b/test/HttpHeaderProcessorTest.cc
@@ -76,7 +76,7 @@ void HttpHeaderProcessorTest::testParse3()
     "Content-Type:\r\n"
     "\r\n";
   CPPUNIT_ASSERT(proc.parse(s));
-  SharedHandle<HttpHeader> h = proc.getResult();
+  std::shared_ptr<HttpHeader> h = proc.getResult();
   CPPUNIT_ASSERT_EQUAL(std::string("close"), h->find(HttpHeader::CONNECTION));
   CPPUNIT_ASSERT_EQUAL(std::string("text1 text2 text3"),
                        h->find(HttpHeader::ACCEPT_ENCODING));
@@ -136,7 +136,7 @@ void HttpHeaderProcessorTest::testGetHttpResponseHeader()
 
   CPPUNIT_ASSERT(proc.parse(hd));
 
-  SharedHandle<HttpHeader> header = proc.getResult();
+  std::shared_ptr<HttpHeader> header = proc.getResult();
   CPPUNIT_ASSERT_EQUAL(404, header->getStatusCode());
   CPPUNIT_ASSERT_EQUAL(std::string("Not Found"), header->getReasonPhrase());
   CPPUNIT_ASSERT_EQUAL(std::string("HTTP/1.1"), header->getVersion());
@@ -153,7 +153,7 @@ void HttpHeaderProcessorTest::testGetHttpResponseHeader_statusOnly()
 
   std::string hd = "HTTP/1.1 200\r\n\r\n";
   CPPUNIT_ASSERT(proc.parse(hd));
-  SharedHandle<HttpHeader> header = proc.getResult();
+  std::shared_ptr<HttpHeader> header = proc.getResult();
   CPPUNIT_ASSERT_EQUAL(200, header->getStatusCode());
 }
 
@@ -269,7 +269,7 @@ void HttpHeaderProcessorTest::testGetHttpRequestHeader()
 
   CPPUNIT_ASSERT(proc.parse(request));
 
-  SharedHandle<HttpHeader> httpHeader = proc.getResult();
+  std::shared_ptr<HttpHeader> httpHeader = proc.getResult();
   CPPUNIT_ASSERT_EQUAL(std::string("GET"), httpHeader->getMethod());
   CPPUNIT_ASSERT_EQUAL(std::string("/index.html"),httpHeader->getRequestPath());
   CPPUNIT_ASSERT_EQUAL(std::string("HTTP/1.1"), httpHeader->getVersion());
diff --git a/test/HttpRequestTest.cc b/test/HttpRequestTest.cc
index 0a833194..ffe4d128 100644
--- a/test/HttpRequestTest.cc
+++ b/test/HttpRequestTest.cc
@@ -40,8 +40,8 @@ class HttpRequestTest : public CppUnit::TestFixture {
   CPPUNIT_TEST(testConditionalRequest);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<Option> option_;
-  SharedHandle<AuthConfigFactory> authConfigFactory_;
+  std::shared_ptr<Option> option_;
+  std::shared_ptr<AuthConfigFactory> authConfigFactory_;
 public:
   void setUp()
   {
@@ -74,9 +74,9 @@ CPPUNIT_TEST_SUITE_REGISTRATION( HttpRequestTest );
 void HttpRequestTest::testGetStartByte()
 {
   HttpRequest httpRequest;
-  SharedHandle<Piece> p(new Piece(1, 1024));
-  SharedHandle<Segment> segment(new PiecedSegment(1024, p));
-  SharedHandle<FileEntry> fileEntry(new FileEntry("file", 1024*10, 0));
+  std::shared_ptr<Piece> p(new Piece(1, 1024));
+  std::shared_ptr<Segment> segment(new PiecedSegment(1024, p));
+  std::shared_ptr<FileEntry> fileEntry(new FileEntry("file", 1024*10, 0));
 
   CPPUNIT_ASSERT_EQUAL((int64_t)0LL, httpRequest.getStartByte());
 
@@ -93,9 +93,9 @@ void HttpRequestTest::testGetEndByte()
   size_t segmentLength = 1024*1024;
 
   HttpRequest httpRequest;
-  SharedHandle<Piece> piece(new Piece(index, length));
-  SharedHandle<Segment> segment(new PiecedSegment(segmentLength, piece));
-  SharedHandle<FileEntry> fileEntry(new FileEntry("file", segmentLength*10, 0));
+  std::shared_ptr<Piece> piece(new Piece(index, length));
+  std::shared_ptr<Segment> segment(new PiecedSegment(segmentLength, piece));
+  std::shared_ptr<FileEntry> fileEntry(new FileEntry("file", segmentLength*10, 0));
 
   CPPUNIT_ASSERT_EQUAL((int64_t)0LL, httpRequest.getEndByte());
 
@@ -103,7 +103,7 @@ void HttpRequestTest::testGetEndByte()
 
   CPPUNIT_ASSERT_EQUAL((int64_t)0LL, httpRequest.getEndByte());
 
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->supportsPersistentConnection(true);
   request->setPipeliningHint(true);
 
@@ -126,16 +126,16 @@ void HttpRequestTest::testGetEndByte()
 
 void HttpRequestTest::testCreateRequest()
 {
-  SharedHandle<Piece> p;
+  std::shared_ptr<Piece> p;
 
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->supportsPersistentConnection(true);
 
   request->setUri("http://localhost:8080/archives/aria2-1.0.0.tar.bz2");
 
   p.reset(new Piece(0, 1024));
-  SharedHandle<Segment> segment(new PiecedSegment(1024, p));
-  SharedHandle<FileEntry> fileEntry(new FileEntry("file", 1024*1024*10, 0));
+  std::shared_ptr<Segment> segment(new PiecedSegment(1024, p));
+  std::shared_ptr<FileEntry> fileEntry(new FileEntry("file", 1024*1024*10, 0));
 
   HttpRequest httpRequest;
   httpRequest.disableContentEncoding();
@@ -259,7 +259,7 @@ void HttpRequestTest::testCreateRequest()
   CPPUNIT_ASSERT_EQUAL(expectedText, httpRequest.createRequest());
 
   // enable http proxy auth
-  SharedHandle<Request> proxyRequest(new Request());
+  std::shared_ptr<Request> proxyRequest(new Request());
   CPPUNIT_ASSERT(proxyRequest->setUri
                  ("http://aria2proxyuser:aria2proxypasswd@localhost:9000"));
   httpRequest.setProxyRequest(proxyRequest);
@@ -316,18 +316,18 @@ void HttpRequestTest::testCreateRequest_ftp()
   option_->put(PREF_FTP_USER, "aria2user");
   option_->put(PREF_FTP_PASSWD, "aria2passwd");
 
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("ftp://localhost:8080/archives/aria2-1.0.0.tar.bz2");
 
-  SharedHandle<Request> proxyRequest(new Request());
+  std::shared_ptr<Request> proxyRequest(new Request());
   CPPUNIT_ASSERT(proxyRequest->setUri
                  ("http://localhost:9000"));
 
   HttpRequest httpRequest;
-  SharedHandle<Piece> p(new Piece(0, 1024*1024));
-  SharedHandle<Segment> segment
+  std::shared_ptr<Piece> p(new Piece(0, 1024*1024));
+  std::shared_ptr<Segment> segment
     (new PiecedSegment(1024*1024, p));
-  SharedHandle<FileEntry> fileEntry(new FileEntry("file", 1024*1024*10, 0));
+  std::shared_ptr<FileEntry> fileEntry(new FileEntry("file", 1024*1024*10, 0));
 
   httpRequest.disableContentEncoding();
   httpRequest.setRequest(request);
@@ -372,12 +372,12 @@ void HttpRequestTest::testCreateRequest_ftp()
 
 void HttpRequestTest::testCreateRequest_with_cookie()
 {
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost/archives/aria2-1.0.0.tar.bz2");
-  SharedHandle<Piece> p(new Piece(0, 1024*1024));
-  SharedHandle<Segment> segment
+  std::shared_ptr<Piece> p(new Piece(0, 1024*1024));
+  std::shared_ptr<Segment> segment
     (new PiecedSegment(1024*1024, p));
-  SharedHandle<FileEntry> fileEntry(new FileEntry("file", 1024*1024*10, 0));
+  std::shared_ptr<FileEntry> fileEntry(new FileEntry("file", 1024*1024*10, 0));
 
   Cookie cookies[] = {
     createCookie("name1", "value1", "localhost", true, "/archives", false),
@@ -388,7 +388,7 @@ void HttpRequestTest::testCreateRequest_with_cookie()
     createCookie("name4", "value4", "aria2.org", false, "/archives/", true),
     createCookie("name5", "value5", "example.org", false, "/", false)
   };
-  SharedHandle<CookieStorage> st(new CookieStorage());
+  std::shared_ptr<CookieStorage> st(new CookieStorage());
   for(size_t i = 0; i < A2_ARRAY_LEN(cookies); ++i) {
     CPPUNIT_ASSERT(st->store(cookies[i], 0));
   }
@@ -489,7 +489,7 @@ void HttpRequestTest::testCreateRequest_with_cookie()
 
 void HttpRequestTest::testCreateRequest_query()
 {
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost/wiki?id=9ad5109a-b8a5-4edf-9373-56a1c34ae138");
   HttpRequest httpRequest;
   httpRequest.disableContentEncoding();
@@ -511,7 +511,7 @@ void HttpRequestTest::testCreateRequest_query()
 
 void HttpRequestTest::testCreateRequest_head()
 {
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->setMethod(Request::METHOD_HEAD);
   request->setUri("http://localhost/aria2-1.0.0.tar.bz2");
 
@@ -528,17 +528,17 @@ void HttpRequestTest::testCreateRequest_head()
 
 void HttpRequestTest::testCreateRequest_endOffsetOverride()
 {
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost/myfile");
   HttpRequest httpRequest;
   httpRequest.disableContentEncoding();
   httpRequest.setRequest(request);
   httpRequest.setAuthConfigFactory(authConfigFactory_, option_.get());
-  SharedHandle<Piece> p(new Piece(0, 1024*1024));
-  SharedHandle<Segment> segment(new PiecedSegment(1024*1024, p));
+  std::shared_ptr<Piece> p(new Piece(0, 1024*1024));
+  std::shared_ptr<Segment> segment(new PiecedSegment(1024*1024, p));
   httpRequest.setSegment(segment);
   httpRequest.setEndOffsetOverride(1024*1024*1024);
-  SharedHandle<FileEntry> fileEntry
+  std::shared_ptr<FileEntry> fileEntry
     (new FileEntry("file", 1024*1024*1024*10LL, 0));
   httpRequest.setFileEntry(fileEntry);
   // End byte is passed if it is not 0
@@ -573,12 +573,12 @@ void HttpRequestTest::testCreateRequest_endOffsetOverride()
 
 void HttpRequestTest::testCreateProxyRequest()
 {
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost/archives/aria2-1.0.0.tar.bz2");
-  SharedHandle<Piece> p(new Piece(0, 1024*1024));
-  SharedHandle<Segment> segment(new PiecedSegment(1024*1024, p));
+  std::shared_ptr<Piece> p(new Piece(0, 1024*1024));
+  std::shared_ptr<Segment> segment(new PiecedSegment(1024*1024, p));
 
-  SharedHandle<Request> proxyRequest(new Request());
+  std::shared_ptr<Request> proxyRequest(new Request());
   CPPUNIT_ASSERT(proxyRequest->setUri("http://localhost:9000"));
 
   HttpRequest httpRequest;
@@ -636,13 +636,13 @@ void HttpRequestTest::testCreateProxyRequest()
 
 void HttpRequestTest::testIsRangeSatisfied()
 {
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->supportsPersistentConnection(true);
   request->setUri("http://localhost:8080/archives/aria2-1.0.0.tar.bz2");
   request->setPipeliningHint(false); // default: false
-  SharedHandle<Piece> p(new Piece(0, 1024*1024));
-  SharedHandle<Segment> segment(new PiecedSegment(1024*1024, p));
-  SharedHandle<FileEntry> fileEntry(new FileEntry("file", 0, 0));
+  std::shared_ptr<Piece> p(new Piece(0, 1024*1024));
+  std::shared_ptr<Segment> segment(new PiecedSegment(1024*1024, p));
+  std::shared_ptr<FileEntry> fileEntry(new FileEntry("file", 0, 0));
 
   HttpRequest httpRequest;
 
@@ -699,11 +699,11 @@ void HttpRequestTest::testIsRangeSatisfied()
 
 void HttpRequestTest::testUserAgent()
 {
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost:8080/archives/aria2-1.0.0.tar.bz2");
 
-  //SharedHandle<Piece> p(new Piece(0, 1024));
-  //SharedHandle<Segment> segment(new PiecedSegment(1024, p));
+  //std::shared_ptr<Piece> p(new Piece(0, 1024));
+  //std::shared_ptr<Segment> segment(new PiecedSegment(1024, p));
 
   HttpRequest httpRequest;
   httpRequest.disableContentEncoding();
@@ -723,7 +723,7 @@ void HttpRequestTest::testUserAgent()
 
   CPPUNIT_ASSERT_EQUAL(expectedText, httpRequest.createRequest());
 
-  SharedHandle<Request> proxyRequest(new Request());
+  std::shared_ptr<Request> proxyRequest(new Request());
   CPPUNIT_ASSERT(proxyRequest->setUri("http://localhost:9000"));
 
   httpRequest.setProxyRequest(proxyRequest);
@@ -739,7 +739,7 @@ void HttpRequestTest::testUserAgent()
 
 void HttpRequestTest::testAddHeader()
 {
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost/archives/aria2-1.0.0.tar.bz2");
 
   HttpRequest httpRequest;
@@ -764,7 +764,7 @@ void HttpRequestTest::testAddHeader()
 
 void HttpRequestTest::testAcceptMetalink()
 {
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost/archives/aria2-1.0.0.tar.bz2");
 
   HttpRequest httpRequest;
@@ -788,7 +788,7 @@ void HttpRequestTest::testAcceptMetalink()
 
 void HttpRequestTest::testEnableAcceptEncoding()
 {
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost/archives/aria2-1.0.0.tar.bz2");
 
   HttpRequest httpRequest;
@@ -829,7 +829,7 @@ void HttpRequestTest::testEnableAcceptEncoding()
 
 void HttpRequestTest::testCreateRequest_ipv6LiteralAddr()
 {
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://[::1]/path");
   HttpRequest httpRequest;
   httpRequest.disableContentEncoding();
@@ -838,7 +838,7 @@ void HttpRequestTest::testCreateRequest_ipv6LiteralAddr()
 
   CPPUNIT_ASSERT(httpRequest.createRequest().find("Host: [::1]") != std::string::npos);
 
-  SharedHandle<Request> proxy(new Request());
+  std::shared_ptr<Request> proxy(new Request());
   proxy->setUri("http://proxy");
   httpRequest.setProxyRequest(proxy);
   std::string proxyRequest = httpRequest.createProxyRequest();
diff --git a/test/HttpResponseTest.cc b/test/HttpResponseTest.cc
index 49a59b28..3520e4fb 100644
--- a/test/HttpResponseTest.cc
+++ b/test/HttpResponseTest.cc
@@ -106,7 +106,7 @@ void HttpResponseTest::testGetContentLength_contentLength()
 {
   HttpResponse httpResponse;
 
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpHeader->put(HttpHeader::CONTENT_LENGTH, "4294967296");
 
   httpResponse.setHttpHeader(httpHeader);
@@ -118,7 +118,7 @@ void HttpResponseTest::testGetEntityLength()
 {
   HttpResponse httpResponse;
 
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpHeader->put(HttpHeader::CONTENT_LENGTH, "4294967296");
 
   httpResponse.setHttpHeader(httpHeader);
@@ -134,7 +134,7 @@ void HttpResponseTest::testGetEntityLength()
 void HttpResponseTest::testGetContentType()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpHeader->put(HttpHeader::CONTENT_TYPE,
                   "application/metalink+xml; charset=UTF-8");
   httpResponse.setHttpHeader(httpHeader);
@@ -146,9 +146,9 @@ void HttpResponseTest::testGetContentType()
 void HttpResponseTest::testDeterminFilename_without_ContentDisposition()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
-  SharedHandle<HttpRequest> httpRequest(new HttpRequest());
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost/archives/aria2-1.0.0.tar.bz2");
   httpRequest->setRequest(request);
 
@@ -163,10 +163,10 @@ void HttpResponseTest::testDeterminFilename_with_ContentDisposition_zero_length
 ()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpHeader->put(HttpHeader::CONTENT_DISPOSITION, "attachment; filename=\"\"");
-  SharedHandle<HttpRequest> httpRequest(new HttpRequest());
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost/archives/aria2-1.0.0.tar.bz2");
   httpRequest->setRequest(request);
 
@@ -180,11 +180,11 @@ void HttpResponseTest::testDeterminFilename_with_ContentDisposition_zero_length
 void HttpResponseTest::testDeterminFilename_with_ContentDisposition()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpHeader->put(HttpHeader::CONTENT_DISPOSITION,
                   "attachment; filename=\"aria2-current.tar.bz2\"");
-  SharedHandle<HttpRequest> httpRequest(new HttpRequest());
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost/archives/aria2-1.0.0.tar.bz2");
   httpRequest->setRequest(request);
 
@@ -198,7 +198,7 @@ void HttpResponseTest::testDeterminFilename_with_ContentDisposition()
 void HttpResponseTest::testGetRedirectURI_without_Location()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
 
   httpResponse.setHttpHeader(httpHeader);
 
@@ -209,7 +209,7 @@ void HttpResponseTest::testGetRedirectURI_without_Location()
 void HttpResponseTest::testGetRedirectURI_with_Location()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpHeader->put(HttpHeader::LOCATION, "http://localhost/download/aria2-1.0.0.tar.bz2");
   httpResponse.setHttpHeader(httpHeader);
 
@@ -221,7 +221,7 @@ void HttpResponseTest::testGetRedirectURI_with_Location()
 void HttpResponseTest::testIsRedirect()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpHeader->setStatusCode(200);
   httpHeader->put(HttpHeader::LOCATION,
                   "http://localhost/download/aria2-1.0.0.tar.bz2");
@@ -238,7 +238,7 @@ void HttpResponseTest::testIsRedirect()
 void HttpResponseTest::testIsTransferEncodingSpecified()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
 
   httpResponse.setHttpHeader(httpHeader);
 
@@ -252,7 +252,7 @@ void HttpResponseTest::testIsTransferEncodingSpecified()
 void HttpResponseTest::testGetTransferEncoding()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
 
   httpResponse.setHttpHeader(httpHeader);
 
@@ -267,7 +267,7 @@ void HttpResponseTest::testGetTransferEncoding()
 void HttpResponseTest::testGetTransferEncodingStreamFilter()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
 
   httpResponse.setHttpHeader(httpHeader);
 
@@ -281,7 +281,7 @@ void HttpResponseTest::testGetTransferEncodingStreamFilter()
 void HttpResponseTest::testIsContentEncodingSpecified()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
 
   httpResponse.setHttpHeader(httpHeader);
 
@@ -295,7 +295,7 @@ void HttpResponseTest::testIsContentEncodingSpecified()
 void HttpResponseTest::testGetContentEncoding()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
 
   httpResponse.setHttpHeader(httpHeader);
 
@@ -309,7 +309,7 @@ void HttpResponseTest::testGetContentEncoding()
 void HttpResponseTest::testGetContentEncodingStreamFilter()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
 
   httpResponse.setHttpHeader(httpHeader);
 
@@ -318,7 +318,7 @@ void HttpResponseTest::testGetContentEncodingStreamFilter()
 #ifdef HAVE_ZLIB
   httpHeader->put(HttpHeader::CONTENT_ENCODING, "gzip");
   {
-    SharedHandle<StreamFilter> filter =
+    std::shared_ptr<StreamFilter> filter =
       httpResponse.getContentEncodingStreamFilter();
     CPPUNIT_ASSERT(filter);
     CPPUNIT_ASSERT_EQUAL(std::string("GZipDecodingStreamFilter"),
@@ -328,7 +328,7 @@ void HttpResponseTest::testGetContentEncodingStreamFilter()
   httpResponse.setHttpHeader(httpHeader);
   httpHeader->put(HttpHeader::CONTENT_ENCODING, "deflate");
   {
-    SharedHandle<StreamFilter> filter =
+    std::shared_ptr<StreamFilter> filter =
       httpResponse.getContentEncodingStreamFilter();
     CPPUNIT_ASSERT(filter);
     CPPUNIT_ASSERT_EQUAL(std::string("GZipDecodingStreamFilter"),
@@ -339,7 +339,7 @@ void HttpResponseTest::testGetContentEncodingStreamFilter()
   httpResponse.setHttpHeader(httpHeader);
   httpHeader->put(HttpHeader::CONTENT_ENCODING, "bzip2");
   {
-    SharedHandle<StreamFilter> filter =
+    std::shared_ptr<StreamFilter> filter =
       httpResponse.getContentEncodingStreamFilter();
     CPPUNIT_ASSERT(!filter);
   }
@@ -348,7 +348,7 @@ void HttpResponseTest::testGetContentEncodingStreamFilter()
 void HttpResponseTest::testValidateResponse()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpResponse.setHttpHeader(httpHeader);
 
   httpHeader->setStatusCode(301);
@@ -371,16 +371,16 @@ void HttpResponseTest::testValidateResponse()
 void HttpResponseTest::testValidateResponse_good_range()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpResponse.setHttpHeader(httpHeader);
 
-  SharedHandle<HttpRequest> httpRequest(new HttpRequest());
-  SharedHandle<Piece> p(new Piece(1, 1024*1024));
-  SharedHandle<Segment> segment(new PiecedSegment(1024*1024, p));
+  std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
+  std::shared_ptr<Piece> p(new Piece(1, 1024*1024));
+  std::shared_ptr<Segment> segment(new PiecedSegment(1024*1024, p));
   httpRequest->setSegment(segment);
-  SharedHandle<FileEntry> fileEntry(new FileEntry("file", 1024*1024*10, 0));
+  std::shared_ptr<FileEntry> fileEntry(new FileEntry("file", 1024*1024*10, 0));
   httpRequest->setFileEntry(fileEntry);
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost/archives/aria2-1.0.0.tar.bz2");
   httpRequest->setRequest(request);
   httpResponse.setHttpRequest(httpRequest);
@@ -398,16 +398,16 @@ void HttpResponseTest::testValidateResponse_good_range()
 void HttpResponseTest::testValidateResponse_bad_range()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpResponse.setHttpHeader(httpHeader);
 
-  SharedHandle<HttpRequest> httpRequest(new HttpRequest());
-  SharedHandle<Piece> p(new Piece(1, 1024*1024));
-  SharedHandle<Segment> segment(new PiecedSegment(1024*1024, p));
+  std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
+  std::shared_ptr<Piece> p(new Piece(1, 1024*1024));
+  std::shared_ptr<Segment> segment(new PiecedSegment(1024*1024, p));
   httpRequest->setSegment(segment);
-  SharedHandle<FileEntry> fileEntry(new FileEntry("file", 1024*1024*10, 0));
+  std::shared_ptr<FileEntry> fileEntry(new FileEntry("file", 1024*1024*10, 0));
   httpRequest->setFileEntry(fileEntry);
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost/archives/aria2-1.0.0.tar.bz2");
   httpRequest->setRequest(request);
   httpResponse.setHttpRequest(httpRequest);
@@ -424,16 +424,16 @@ void HttpResponseTest::testValidateResponse_bad_range()
 void HttpResponseTest::testValidateResponse_chunked()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpResponse.setHttpHeader(httpHeader);
 
-  SharedHandle<HttpRequest> httpRequest(new HttpRequest());
-  SharedHandle<Piece> p(new Piece(1, 1024*1024));
-  SharedHandle<Segment> segment(new PiecedSegment(1024*1024, p));
+  std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
+  std::shared_ptr<Piece> p(new Piece(1, 1024*1024));
+  std::shared_ptr<Segment> segment(new PiecedSegment(1024*1024, p));
   httpRequest->setSegment(segment);
-  SharedHandle<FileEntry> fileEntry(new FileEntry("file", 1024*1024*10, 0));
+  std::shared_ptr<FileEntry> fileEntry(new FileEntry("file", 1024*1024*10, 0));
   httpRequest->setFileEntry(fileEntry);
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost/archives/aria2-1.0.0.tar.bz2");
   httpRequest->setRequest(request);
   httpResponse.setHttpRequest(httpRequest);
@@ -452,10 +452,10 @@ void HttpResponseTest::testValidateResponse_chunked()
 void HttpResponseTest::testValidateResponse_withIfModifiedSince()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpResponse.setHttpHeader(httpHeader);
   httpHeader->setStatusCode(304);
-  SharedHandle<HttpRequest> httpRequest(new HttpRequest());
+  std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
   httpResponse.setHttpRequest(httpRequest);
   try {
     httpResponse.validateResponse();
@@ -469,11 +469,11 @@ void HttpResponseTest::testValidateResponse_withIfModifiedSince()
 void HttpResponseTest::testProcessRedirect()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpResponse.setHttpHeader(httpHeader);
 
-  SharedHandle<HttpRequest> httpRequest(new HttpRequest());
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://localhost/archives/aria2-1.0.0.tar.bz2");
   httpRequest->setRequest(request);
   httpResponse.setHttpRequest(httpRequest);
@@ -507,14 +507,14 @@ void HttpResponseTest::testProcessRedirect()
 void HttpResponseTest::testRetrieveCookie()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpResponse.setHttpHeader(httpHeader);
 
-  SharedHandle<HttpRequest> httpRequest(new HttpRequest());
-  SharedHandle<Request> request(new Request());
+  std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
+  std::shared_ptr<Request> request(new Request());
   request->setUri("http://www.aria2.org/archives/aria2-1.0.0.tar.bz2");
   httpRequest->setRequest(request);
-  SharedHandle<CookieStorage> st(new CookieStorage());
+  std::shared_ptr<CookieStorage> st(new CookieStorage());
   httpRequest->setCookieStorage(st);
   httpResponse.setHttpRequest(httpRequest);
 
@@ -539,9 +539,9 @@ void HttpResponseTest::testRetrieveCookie()
 void HttpResponseTest::testSupportsPersistentConnection()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpResponse.setHttpHeader(httpHeader);
-  SharedHandle<HttpRequest> httpRequest(new HttpRequest());
+  std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
   httpResponse.setHttpRequest(httpRequest);
 
   httpHeader->setVersion("HTTP/1.1");
@@ -563,7 +563,7 @@ void HttpResponseTest::testSupportsPersistentConnection()
   httpHeader->clearField();
 
   // test proxy connection
-  SharedHandle<Request> proxyRequest(new Request());
+  std::shared_ptr<Request> proxyRequest(new Request());
   httpRequest->setProxyRequest(proxyRequest);
 
   httpHeader->setVersion("HTTP/1.1");
@@ -588,9 +588,9 @@ void HttpResponseTest::testSupportsPersistentConnection()
 void HttpResponseTest::testGetMetalinKHttpEntries()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpResponse.setHttpHeader(httpHeader);
-  SharedHandle<Option> option(new Option());
+  std::shared_ptr<Option> option(new Option());
 
   httpHeader->put(HttpHeader::LINK,
                   "<http://uri1/>; rel=duplicate; pri=1; pref; geo=JP");
@@ -641,9 +641,9 @@ void HttpResponseTest::testGetMetalinKHttpEntries()
 void HttpResponseTest::testGetDigest()
 {
   HttpResponse httpResponse;
-  SharedHandle<HttpHeader> httpHeader(new HttpHeader());
+  std::shared_ptr<HttpHeader> httpHeader(new HttpHeader());
   httpResponse.setHttpHeader(httpHeader);
-  SharedHandle<Option> option(new Option());
+  std::shared_ptr<Option> option(new Option());
   // Python binascii.hexlify(base64.b64decode(B64ED_HASH)) is handy to
   // retrieve ascii hex hash string.
   httpHeader->put(HttpHeader::DIGEST, "SHA-1=82AD8itGL/oYQ5BTPFANiYnp9oE=");
diff --git a/test/IndexedListTest.cc b/test/IndexedListTest.cc
index 65801ebc..1f28b588 100644
--- a/test/IndexedListTest.cc
+++ b/test/IndexedListTest.cc
@@ -237,7 +237,7 @@ namespace {
 struct KeyFunc {
   int n;
   KeyFunc(int n):n(n) {}
-  int operator()(const SharedHandle<std::string>& x)
+  int operator()(const std::shared_ptr<std::string>& x)
   {
     return n++;
   }
@@ -246,14 +246,14 @@ struct KeyFunc {
 
 void IndexedListTest::testInsert_keyFunc()
 {
-  SharedHandle<std::string> s[] = {
-    SharedHandle<std::string>(new std::string("a")),
-    SharedHandle<std::string>(new std::string("b")),
-    SharedHandle<std::string>(new std::string("c")),
-    SharedHandle<std::string>(new std::string("d"))
+  std::shared_ptr<std::string> s[] = {
+    std::shared_ptr<std::string>(new std::string("a")),
+    std::shared_ptr<std::string>(new std::string("b")),
+    std::shared_ptr<std::string>(new std::string("c")),
+    std::shared_ptr<std::string>(new std::string("d"))
   };
   size_t slen = sizeof(s)/sizeof(s[0]);
-  IndexedList<int, SharedHandle<std::string> > list;
+  IndexedList<int, std::shared_ptr<std::string> > list;
   list.insert(list.begin(), KeyFunc(0), vbegin(s), vend(s));
   CPPUNIT_ASSERT_EQUAL((size_t)slen, list.size());
   for(size_t i = 0; i < slen; ++i) {
@@ -264,7 +264,7 @@ void IndexedListTest::testInsert_keyFunc()
   for(size_t i = slen; i < slen*2; ++i) {
     CPPUNIT_ASSERT_EQUAL(*s[i - slen], *list.get(i));
   }
-  IndexedList<int, SharedHandle<std::string> >::iterator itr;
+  IndexedList<int, std::shared_ptr<std::string> >::iterator itr;
   itr = list.begin();
   CPPUNIT_ASSERT_EQUAL(std::string("a"), *(*itr++));
   CPPUNIT_ASSERT_EQUAL(std::string("b"), *(*itr++));
diff --git a/test/InorderURISelectorTest.cc b/test/InorderURISelectorTest.cc
index 831780f8..f607471e 100644
--- a/test/InorderURISelectorTest.cc
+++ b/test/InorderURISelectorTest.cc
@@ -17,7 +17,7 @@ class InorderURISelectorTest:public CppUnit::TestFixture {
 private:
   FileEntry fileEntry_;
 
-  SharedHandle<InorderURISelector> sel;
+  std::shared_ptr<InorderURISelector> sel;
 
 public:
   void setUp()
diff --git a/test/IteratableChecksumValidatorTest.cc b/test/IteratableChecksumValidatorTest.cc
index a4419dc6..42b810f4 100644
--- a/test/IteratableChecksumValidatorTest.cc
+++ b/test/IteratableChecksumValidatorTest.cc
@@ -33,11 +33,11 @@ CPPUNIT_TEST_SUITE_REGISTRATION( IteratableChecksumValidatorTest );
 
 void IteratableChecksumValidatorTest::testValidate() {
   Option option;
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(100, 250, A2_TEST_DIR"/chunkChecksumTestFile250.txt"));
   dctx->setDigest("sha-1",
                   fromHex("898a81b8e0181280ae2ee1b81e269196d91e869a"));
-  SharedHandle<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &option));
+  std::shared_ptr<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &option));
   ps->initStorage();
   ps->getDiskAdaptor()->enableReadOnly();
   ps->getDiskAdaptor()->openFile();
@@ -53,11 +53,11 @@ void IteratableChecksumValidatorTest::testValidate() {
 
 void IteratableChecksumValidatorTest::testValidate_fail() {
   Option option;
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(100, 250, A2_TEST_DIR"/chunkChecksumTestFile250.txt"));
   dctx->setDigest("sha-1",
                   fromHex(std::string(40, '0'))); // set wrong checksum
-  SharedHandle<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &option));
+  std::shared_ptr<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &option));
   ps->initStorage();
   ps->getDiskAdaptor()->enableReadOnly();
   ps->getDiskAdaptor()->openFile();
diff --git a/test/IteratableChunkChecksumValidatorTest.cc b/test/IteratableChunkChecksumValidatorTest.cc
index 3e1cac84..5c8b2995 100644
--- a/test/IteratableChunkChecksumValidatorTest.cc
+++ b/test/IteratableChunkChecksumValidatorTest.cc
@@ -39,10 +39,10 @@ const std::string IteratableChunkChecksumValidatorTest::csArray[] =
 
 void IteratableChunkChecksumValidatorTest::testValidate() {
   Option option;
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(100, 250, A2_TEST_DIR"/chunkChecksumTestFile250.txt"));
   dctx->setPieceHashes("sha-1", &csArray[0], &csArray[3]);
-  SharedHandle<DefaultPieceStorage> ps
+  std::shared_ptr<DefaultPieceStorage> ps
     (new DefaultPieceStorage(dctx, &option));
   ps->initStorage();
   ps->getDiskAdaptor()->enableReadOnly();
@@ -76,13 +76,13 @@ void IteratableChunkChecksumValidatorTest::testValidate() {
 
 void IteratableChunkChecksumValidatorTest::testValidate_readError() {
   Option option;
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(100, 500, A2_TEST_DIR"/chunkChecksumTestFile250.txt"));
   std::deque<std::string> hashes(&csArray[0], &csArray[3]);
   hashes.push_back(fromHex("ffffffffffffffffffffffffffffffffffffffff"));
   hashes.push_back(fromHex("ffffffffffffffffffffffffffffffffffffffff"));
   dctx->setPieceHashes("sha-1", hashes.begin(), hashes.end());
-  SharedHandle<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &option));
+  std::shared_ptr<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &option));
   ps->initStorage();
   ps->getDiskAdaptor()->enableReadOnly();
   ps->getDiskAdaptor()->openFile();
diff --git a/test/JsonTest.cc b/test/JsonTest.cc
index aac95f70..db3391a9 100644
--- a/test/JsonTest.cc
+++ b/test/JsonTest.cc
@@ -27,13 +27,13 @@ CPPUNIT_TEST_SUITE_REGISTRATION( JsonTest );
 void JsonTest::testEncode()
 {
   {
-    SharedHandle<Dict> dict = Dict::g();
+    std::shared_ptr<Dict> dict = Dict::g();
     dict->put("name", String::g("aria2"));
     dict->put("loc", Integer::g(80000));
-    SharedHandle<List> files = List::g();
+    std::shared_ptr<List> files = List::g();
     files->append(String::g("aria2c"));
     dict->put("files", files);
-    SharedHandle<Dict> attrs = Dict::g();
+    std::shared_ptr<Dict> attrs = Dict::g();
     attrs->put("license", String::g("GPL"));
     dict->put("attrs", attrs);
 
@@ -44,13 +44,13 @@ void JsonTest::testEncode()
                          json::encode(dict));
   }
   {
-    SharedHandle<List> list = List::g();
+    std::shared_ptr<List> list = List::g();
     list->append("\"\\/\b\f\n\r\t");
     CPPUNIT_ASSERT_EQUAL(std::string("[\"\\\"\\\\\\/\\b\\f\\n\\r\\t\"]"),
                          json::encode(list));
   }
   {
-    SharedHandle<List> list = List::g();
+    std::shared_ptr<List> list = List::g();
     std::string s;
     s += 0x1Fu;
     list->append(s);
@@ -58,7 +58,7 @@ void JsonTest::testEncode()
                          json::encode(list));
   }
   {
-    SharedHandle<List> list = List::g();
+    std::shared_ptr<List> list = List::g();
     list->append(Bool::gTrue());
     list->append(Bool::gFalse());
     list->append(Null::g());
diff --git a/test/LpdMessageDispatcherTest.cc b/test/LpdMessageDispatcherTest.cc
index 0cbb0d56..f6c47c20 100644
--- a/test/LpdMessageDispatcherTest.cc
+++ b/test/LpdMessageDispatcherTest.cc
@@ -43,7 +43,7 @@ void LpdMessageDispatcherTest::testCreateLpdRequest()
 
 void LpdMessageDispatcherTest::testSendMessage()
 {
-  SharedHandle<SocketCore> recvsock(new SocketCore(SOCK_DGRAM));
+  std::shared_ptr<SocketCore> recvsock(new SocketCore(SOCK_DGRAM));
 #ifdef __MINGW32__
   recvsock->bindWithFamily(LPD_MULTICAST_PORT, AF_INET);
 #else // !__MINGW32__
diff --git a/test/LpdMessageReceiverTest.cc b/test/LpdMessageReceiverTest.cc
index ad807b26..26aefc9b 100644
--- a/test/LpdMessageReceiverTest.cc
+++ b/test/LpdMessageReceiverTest.cc
@@ -33,7 +33,7 @@ void LpdMessageReceiverTest::testReceiveMessage()
   LpdMessageReceiver rcv(LPD_MULTICAST_ADDR, LPD_MULTICAST_PORT);
   CPPUNIT_ASSERT(rcv.init(""));
 
-  SharedHandle<SocketCore> sendsock(new SocketCore(SOCK_DGRAM));
+  std::shared_ptr<SocketCore> sendsock(new SocketCore(SOCK_DGRAM));
   sendsock->create(AF_INET);
   // Mingw32 build needs to set interface explicitly.
   sendsock->setMulticastInterface("");
@@ -50,7 +50,7 @@ void LpdMessageReceiverTest::testReceiveMessage()
                       LPD_MULTICAST_ADDR, LPD_MULTICAST_PORT);
 
   rcv.getSocket()->isReadable(5);
-  SharedHandle<LpdMessage> msg = rcv.receiveMessage();
+  std::shared_ptr<LpdMessage> msg = rcv.receiveMessage();
   CPPUNIT_ASSERT(msg);
   CPPUNIT_ASSERT_EQUAL(std::string("cd41c7fdddfd034a15a04d7ff881216e01c4ceaf"),
                        util::toHex(msg->infoHash));
diff --git a/test/MSEHandshakeTest.cc b/test/MSEHandshakeTest.cc
index 46f96306..002a86e2 100644
--- a/test/MSEHandshakeTest.cc
+++ b/test/MSEHandshakeTest.cc
@@ -22,10 +22,10 @@ class MSEHandshakeTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testHandshake);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<DownloadContext> dctx_;
+  std::shared_ptr<DownloadContext> dctx_;
 
-  void doHandshake(const SharedHandle<MSEHandshake>& initiator,
-                   const SharedHandle<MSEHandshake>& receiver);
+  void doHandshake(const std::shared_ptr<MSEHandshake>& initiator,
+                   const std::shared_ptr<MSEHandshake>& receiver);
 
 public:
   void setUp()
@@ -33,7 +33,7 @@ public:
     dctx_.reset(new DownloadContext());
     unsigned char infoHash[20];
     memset(infoHash, 0, sizeof(infoHash));
-    SharedHandle<TorrentAttribute> torrentAttrs(new TorrentAttribute());
+    std::shared_ptr<TorrentAttribute> torrentAttrs(new TorrentAttribute());
     torrentAttrs->infoHash = std::string(vbegin(infoHash), vend(infoHash));
     dctx_->setAttribute(CTX_ATTR_BT, torrentAttrs);
   }
@@ -45,10 +45,10 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION(MSEHandshakeTest);
 
 namespace {
-std::pair<SharedHandle<SocketCore>, SharedHandle<SocketCore> >
+std::pair<std::shared_ptr<SocketCore>, std::shared_ptr<SocketCore> >
 createSocketPair()
 {
-  SharedHandle<SocketCore> initiatorSock(new SocketCore());
+  std::shared_ptr<SocketCore> initiatorSock(new SocketCore());
 
   SocketCore receiverServerSock;
   receiverServerSock.bind(0);
@@ -60,15 +60,15 @@ createSocketPair()
   initiatorSock->establishConnection("localhost", receiverAddrInfo.second);
   initiatorSock->setBlockingMode();
 
-  SharedHandle<SocketCore> receiverSock(receiverServerSock.acceptConnection());
+  std::shared_ptr<SocketCore> receiverSock(receiverServerSock.acceptConnection());
   receiverSock->setBlockingMode();
 
-  return std::pair<SharedHandle<SocketCore>,
-    SharedHandle<SocketCore> >(initiatorSock, receiverSock);
+  return std::pair<std::shared_ptr<SocketCore>,
+    std::shared_ptr<SocketCore> >(initiatorSock, receiverSock);
 }
 } // namespace
 
-void MSEHandshakeTest::doHandshake(const SharedHandle<MSEHandshake>& initiator, const SharedHandle<MSEHandshake>& receiver)
+void MSEHandshakeTest::doHandshake(const std::shared_ptr<MSEHandshake>& initiator, const std::shared_ptr<MSEHandshake>& receiver)
 {
   initiator->sendPublicKey();
   while(initiator->getWantWrite()) {
@@ -94,7 +94,7 @@ void MSEHandshakeTest::doHandshake(const SharedHandle<MSEHandshake>& initiator,
   while(!receiver->findReceiverHashMarker()) {
     receiver->read();
   }
-  std::vector<SharedHandle<DownloadContext> > contexts;
+  std::vector<std::shared_ptr<DownloadContext> > contexts;
   contexts.push_back(dctx_);
   while(!receiver->receiveReceiverHashAndPadCLength(contexts)) {
     receiver->read();
@@ -125,11 +125,11 @@ void MSEHandshakeTest::doHandshake(const SharedHandle<MSEHandshake>& initiator,
 }
 
 namespace {
-SharedHandle<MSEHandshake>
-createMSEHandshake(SharedHandle<SocketCore> socket, bool initiator,
+std::shared_ptr<MSEHandshake>
+createMSEHandshake(std::shared_ptr<SocketCore> socket, bool initiator,
                    const Option* option)
 {
-  SharedHandle<MSEHandshake> h(new MSEHandshake(1, socket, option));
+  std::shared_ptr<MSEHandshake> h(new MSEHandshake(1, socket, option));
   h->initEncryptionFacility(initiator);
   return h;
 }
@@ -141,10 +141,10 @@ void MSEHandshakeTest::testHandshake()
     Option op;
     op.put(PREF_BT_MIN_CRYPTO_LEVEL, V_PLAIN);
 
-    std::pair<SharedHandle<SocketCore>, SharedHandle<SocketCore> > sockPair =
+    std::pair<std::shared_ptr<SocketCore>, std::shared_ptr<SocketCore> > sockPair =
       createSocketPair();
-    SharedHandle<MSEHandshake> initiator = createMSEHandshake(sockPair.first, true, &op);
-    SharedHandle<MSEHandshake> receiver = createMSEHandshake(sockPair.second, false, &op);
+    std::shared_ptr<MSEHandshake> initiator = createMSEHandshake(sockPair.first, true, &op);
+    std::shared_ptr<MSEHandshake> receiver = createMSEHandshake(sockPair.second, false, &op);
 
     doHandshake(initiator, receiver);
 
@@ -155,10 +155,10 @@ void MSEHandshakeTest::testHandshake()
     Option op;
     op.put(PREF_BT_MIN_CRYPTO_LEVEL, V_ARC4);
 
-    std::pair<SharedHandle<SocketCore>, SharedHandle<SocketCore> > sockPair =
+    std::pair<std::shared_ptr<SocketCore>, std::shared_ptr<SocketCore> > sockPair =
       createSocketPair();
-    SharedHandle<MSEHandshake> initiator = createMSEHandshake(sockPair.first, true, &op);
-    SharedHandle<MSEHandshake> receiver = createMSEHandshake(sockPair.second, false, &op);
+    std::shared_ptr<MSEHandshake> initiator = createMSEHandshake(sockPair.first, true, &op);
+    std::shared_ptr<MSEHandshake> receiver = createMSEHandshake(sockPair.second, false, &op);
 
     doHandshake(initiator, receiver);
 
diff --git a/test/MagnetTest.cc b/test/MagnetTest.cc
index 37af2f07..486de66e 100644
--- a/test/MagnetTest.cc
+++ b/test/MagnetTest.cc
@@ -21,7 +21,7 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION(MagnetTest);
 
 namespace {
-const std::string& nthStr(const SharedHandle<ValueBase>& v, size_t index)
+const std::string& nthStr(const std::shared_ptr<ValueBase>& v, size_t index)
 {
   return downcast<String>(downcast<List>(v)->get(index))->s();
 }
@@ -29,7 +29,7 @@ const std::string& nthStr(const SharedHandle<ValueBase>& v, size_t index)
 
 void MagnetTest::testParse()
 {
-  SharedHandle<Dict> r = parse
+  std::shared_ptr<Dict> r = parse
     ("magnet:?xt=urn:btih:248d0a1cd08284299de78d5c1ed359bb46717d8c&dn=aria2"
      "&tr=http%3A%2F%2Ftracker1&tr=http://tracker2");
   CPPUNIT_ASSERT_EQUAL
diff --git a/test/Makefile.am b/test/Makefile.am
index 6195958a..085bee05 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -31,7 +31,6 @@ aria2c_SOURCES = AllTest.cc\
 	SingletonHolderTest.cc\
 	HttpHeaderTest.cc\
 	HttpResponseTest.cc\
-	SharedHandleTest.cc\
 	FileTest.cc\
 	OptionTest.cc\
 	DefaultDiskWriterTest.cc\
diff --git a/test/MessageDigestHelperTest.cc b/test/MessageDigestHelperTest.cc
index 784dee5c..0cc45bdf 100644
--- a/test/MessageDigestHelperTest.cc
+++ b/test/MessageDigestHelperTest.cc
@@ -26,7 +26,7 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION( MessageDigestHelperTest );
 
 void MessageDigestHelperTest::testDigestDiskWriter() {
-  SharedHandle<DefaultDiskWriter> diskio
+  std::shared_ptr<DefaultDiskWriter> diskio
     (new DefaultDiskWriter(A2_TEST_DIR"/4096chunk.txt"));
   diskio->enableReadOnly();
   diskio->openExistingFile();
diff --git a/test/MessageDigestTest.cc b/test/MessageDigestTest.cc
index c1b25e40..b1618afc 100644
--- a/test/MessageDigestTest.cc
+++ b/test/MessageDigestTest.cc
@@ -17,7 +17,7 @@ class MessageDigestTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testGetCanonicalHashType);
   CPPUNIT_TEST_SUITE_END();
 
-  SharedHandle<MessageDigest> sha1_;
+  std::shared_ptr<MessageDigest> sha1_;
 public:
   void setUp()
   {
diff --git a/test/Metalink2RequestGroupTest.cc b/test/Metalink2RequestGroupTest.cc
index b04584ef..b21658f8 100644
--- a/test/Metalink2RequestGroupTest.cc
+++ b/test/Metalink2RequestGroupTest.cc
@@ -21,7 +21,7 @@ class Metalink2RequestGroupTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testGenerate_dosDirTraversal);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<Option> option_;
+  std::shared_ptr<Option> option_;
 
 public:
   void setUp()
@@ -40,12 +40,12 @@ CPPUNIT_TEST_SUITE_REGISTRATION( Metalink2RequestGroupTest );
 
 void Metalink2RequestGroupTest::testGenerate()
 {
-  std::vector<SharedHandle<RequestGroup> > groups;
+  std::vector<std::shared_ptr<RequestGroup> > groups;
   option_->put(PREF_DIR, "/tmp");
   Metalink2RequestGroup().generate(groups, A2_TEST_DIR"/test.xml", option_);
   // first file
   {
-    SharedHandle<RequestGroup> rg = groups[0];
+    std::shared_ptr<RequestGroup> rg = groups[0];
     std::vector<std::string> uris;
     rg->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     std::sort(uris.begin(), uris.end());
@@ -55,7 +55,7 @@ void Metalink2RequestGroupTest::testGenerate()
     CPPUNIT_ASSERT_EQUAL
       (std::string("http://httphost/aria2-0.5.2.tar.bz2"), uris[1]);
 
-    const SharedHandle<DownloadContext>& dctx = rg->getDownloadContext();
+    const std::shared_ptr<DownloadContext>& dctx = rg->getDownloadContext();
 
     CPPUNIT_ASSERT(dctx);
     CPPUNIT_ASSERT_EQUAL((int64_t)0LL, dctx->getTotalLength());
@@ -70,12 +70,12 @@ void Metalink2RequestGroupTest::testGenerate()
   }
   // second file
   {
-    SharedHandle<RequestGroup> rg = groups[1];
+    std::shared_ptr<RequestGroup> rg = groups[1];
     std::vector<std::string> uris;
     rg->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)2, uris.size());
 
-    const SharedHandle<DownloadContext>& dctx = rg->getDownloadContext();
+    const std::shared_ptr<DownloadContext>& dctx = rg->getDownloadContext();
 
     CPPUNIT_ASSERT(dctx);
 #ifdef ENABLE_MESSAGE_DIGEST
@@ -93,13 +93,13 @@ void Metalink2RequestGroupTest::testGenerate()
 #ifdef ENABLE_BITTORRENT
   // fifth file <- downloading .torrent file
   {
-    SharedHandle<RequestGroup> rg = groups[4];
+    std::shared_ptr<RequestGroup> rg = groups[4];
     std::vector<std::string> uris;
     rg->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)1, uris.size());
     CPPUNIT_ASSERT_EQUAL
       (std::string("http://host/torrent-http.integrated.torrent"), uris[0]);
-    const SharedHandle<DownloadContext>& dctx = rg->getDownloadContext();
+    const std::shared_ptr<DownloadContext>& dctx = rg->getDownloadContext();
 
     CPPUNIT_ASSERT(dctx);
     CPPUNIT_ASSERT_EQUAL(groups[5]->getGID(), rg->belongsTo());
@@ -109,9 +109,9 @@ void Metalink2RequestGroupTest::testGenerate()
   // sixth file <- depends on fifth file to download .torrent file.
   {
 #ifdef ENABLE_BITTORRENT
-    SharedHandle<RequestGroup> rg = groups[5];
+    std::shared_ptr<RequestGroup> rg = groups[5];
 #else
-    SharedHandle<RequestGroup> rg = groups[4];
+    std::shared_ptr<RequestGroup> rg = groups[4];
 #endif // ENABLE_BITTORRENT
     std::vector<std::string> uris;
     rg->getDownloadContext()->getFirstFileEntry()->getUris(uris);
@@ -119,7 +119,7 @@ void Metalink2RequestGroupTest::testGenerate()
     CPPUNIT_ASSERT_EQUAL
       (std::string("http://host/torrent-http.integrated"), uris[0]);
 
-    const SharedHandle<DownloadContext>& dctx = rg->getDownloadContext();
+    const std::shared_ptr<DownloadContext>& dctx = rg->getDownloadContext();
 
     CPPUNIT_ASSERT(dctx);
   }
@@ -127,7 +127,7 @@ void Metalink2RequestGroupTest::testGenerate()
 
 void Metalink2RequestGroupTest::testGenerate_groupByMetaurl()
 {
-  std::vector<SharedHandle<RequestGroup> > groups;
+  std::vector<std::shared_ptr<RequestGroup> > groups;
   Metalink2RequestGroup().generate(groups,
                                    A2_TEST_DIR"/metalink4-groupbymetaurl.xml",
                                    option_);
@@ -136,7 +136,7 @@ void Metalink2RequestGroupTest::testGenerate_groupByMetaurl()
 #ifdef ENABLE_BITTORRENT
   // first RequestGroup is torrent for second RequestGroup
   {
-    SharedHandle<RequestGroup> rg = groups[0];
+    std::shared_ptr<RequestGroup> rg = groups[0];
     std::vector<std::string> uris;
     rg->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)1, uris.size());
@@ -144,9 +144,9 @@ void Metalink2RequestGroupTest::testGenerate_groupByMetaurl()
   }
   // second
   {
-    SharedHandle<RequestGroup> rg = groups[1];
-    SharedHandle<DownloadContext> dctx = rg->getDownloadContext();
-    const std::vector<SharedHandle<FileEntry> >& fileEntries =
+    std::shared_ptr<RequestGroup> rg = groups[1];
+    std::shared_ptr<DownloadContext> dctx = rg->getDownloadContext();
+    const std::vector<std::shared_ptr<FileEntry> >& fileEntries =
       dctx->getFileEntries();
     CPPUNIT_ASSERT_EQUAL((size_t)2, fileEntries.size());
     CPPUNIT_ASSERT_EQUAL(std::string("./file1"), fileEntries[0]->getPath());
@@ -162,9 +162,9 @@ void Metalink2RequestGroupTest::testGenerate_groupByMetaurl()
   }
   // third
   {
-    SharedHandle<RequestGroup> rg = groups[2];
-    SharedHandle<DownloadContext> dctx = rg->getDownloadContext();
-    const std::vector<SharedHandle<FileEntry> >& fileEntries =
+    std::shared_ptr<RequestGroup> rg = groups[2];
+    std::shared_ptr<DownloadContext> dctx = rg->getDownloadContext();
+    const std::vector<std::shared_ptr<FileEntry> >& fileEntries =
       dctx->getFileEntries();
     CPPUNIT_ASSERT_EQUAL((size_t)1, fileEntries.size());
     CPPUNIT_ASSERT_EQUAL(std::string("./file2"), fileEntries[0]->getPath());
@@ -174,21 +174,21 @@ void Metalink2RequestGroupTest::testGenerate_groupByMetaurl()
   }
 #else // !ENABLE_BITTORRENT
   {
-    SharedHandle<RequestGroup> rg = groups[0];
+    std::shared_ptr<RequestGroup> rg = groups[0];
     std::vector<std::string> uris;
     rg->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)1, uris.size());
     CPPUNIT_ASSERT_EQUAL(std::string("http://file1p1"), uris[0]);
   }
   {
-    SharedHandle<RequestGroup> rg = groups[1];
+    std::shared_ptr<RequestGroup> rg = groups[1];
     std::vector<std::string> uris;
     rg->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)1, uris.size());
     CPPUNIT_ASSERT_EQUAL(std::string("http://file2p1"), uris[0]);
   }
   {
-    SharedHandle<RequestGroup> rg = groups[2];
+    std::shared_ptr<RequestGroup> rg = groups[2];
     std::vector<std::string> uris;
     rg->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)1, uris.size());
@@ -202,13 +202,13 @@ void Metalink2RequestGroupTest::testGenerate_dosDirTraversal()
 {
 #ifdef __MINGW32__
 #ifdef ENABLE_BITTORRENT
-  std::vector<SharedHandle<RequestGroup> > groups;
+  std::vector<std::shared_ptr<RequestGroup> > groups;
   option_->put(PREF_DIR, "/tmp");
   Metalink2RequestGroup().generate
     (groups, A2_TEST_DIR"/metalink4-dosdirtraversal.xml", option_);
   CPPUNIT_ASSERT_EQUAL((size_t)3, groups.size());
-  SharedHandle<RequestGroup> rg = groups[0];
-  SharedHandle<FileEntry> file = rg->getDownloadContext()->getFirstFileEntry();
+  std::shared_ptr<RequestGroup> rg = groups[0];
+  std::shared_ptr<FileEntry> file = rg->getDownloadContext()->getFirstFileEntry();
   CPPUNIT_ASSERT_EQUAL(std::string("/tmp/..%5C..%5Cexample.ext"),
                        file->getPath());
 
diff --git a/test/MetalinkEntryTest.cc b/test/MetalinkEntryTest.cc
index a386c7b6..611d9dbe 100644
--- a/test/MetalinkEntryTest.cc
+++ b/test/MetalinkEntryTest.cc
@@ -31,29 +31,29 @@ public:
 
 CPPUNIT_TEST_SUITE_REGISTRATION( MetalinkEntryTest );
 
-SharedHandle<MetalinkEntry> createTestEntry() {
-  SharedHandle<MetalinkEntry> entry(new MetalinkEntry());
-  SharedHandle<MetalinkResource> res1(new MetalinkResource());
+std::shared_ptr<MetalinkEntry> createTestEntry() {
+  std::shared_ptr<MetalinkEntry> entry(new MetalinkEntry());
+  std::shared_ptr<MetalinkResource> res1(new MetalinkResource());
   res1->url = "ftp://myhost/aria2.tar.bz2";
   res1->type = MetalinkResource::TYPE_FTP;
   res1->location = "ro";
   res1->priority = 50;
-  SharedHandle<MetalinkResource> res2(new MetalinkResource());
+  std::shared_ptr<MetalinkResource> res2(new MetalinkResource());
   res2->url = "http://myhost/aria2.tar.bz2";
   res2->type = MetalinkResource::TYPE_HTTP;
   res2->location = "at";
   res2->priority = 1;
-  SharedHandle<MetalinkResource> res3(new MetalinkResource());
+  std::shared_ptr<MetalinkResource> res3(new MetalinkResource());
   res3->url = "http://myhost/aria2.torrent";
   res3->type = MetalinkResource::TYPE_BITTORRENT;
   res3->location = "al";
   res3->priority = 40;
-  SharedHandle<MetalinkResource> res4(new MetalinkResource());
+  std::shared_ptr<MetalinkResource> res4(new MetalinkResource());
   res4->url = "http://myhost/aria2.ext";
   res4->type = MetalinkResource::TYPE_NOT_SUPPORTED;
   res4->location = "ad";
   res4->priority = 90;
-  SharedHandle<MetalinkResource> res5(new MetalinkResource());
+  std::shared_ptr<MetalinkResource> res5(new MetalinkResource());
   res5->url = "https://myhost/aria2.tar.bz2";
   res5->type = MetalinkResource::TYPE_HTTPS;
   res5->location = "jp";
@@ -68,7 +68,7 @@ SharedHandle<MetalinkEntry> createTestEntry() {
 }
 
 void MetalinkEntryTest::testDropUnsupportedResource() {
-  SharedHandle<MetalinkEntry> entry(createTestEntry());
+  std::shared_ptr<MetalinkEntry> entry(createTestEntry());
 
   entry->dropUnsupportedResource();
 #if defined ENABLE_SSL && defined ENABLE_BITTORRENT
@@ -79,7 +79,7 @@ void MetalinkEntryTest::testDropUnsupportedResource() {
   CPPUNIT_ASSERT_EQUAL((size_t)2, entry->resources.size());
 #endif // ENABLE_MESSAGE_DIGEST
 
-  std::vector<SharedHandle<MetalinkResource> >::const_iterator itr =
+  std::vector<std::shared_ptr<MetalinkResource> >::const_iterator itr =
     entry->resources.begin();
   CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP,
                        (*itr++)->type);
@@ -96,7 +96,7 @@ void MetalinkEntryTest::testDropUnsupportedResource() {
 }
 
 void MetalinkEntryTest::testReorderResourcesByPriority() {
-  SharedHandle<MetalinkEntry> entry(createTestEntry());
+  std::shared_ptr<MetalinkEntry> entry(createTestEntry());
 
   entry->reorderResourcesByPriority();
 
@@ -109,7 +109,7 @@ void MetalinkEntryTest::testReorderResourcesByPriority() {
 
 void MetalinkEntryTest::testSetLocationPriority()
 {
-  SharedHandle<MetalinkEntry> entry(createTestEntry());
+  std::shared_ptr<MetalinkEntry> entry(createTestEntry());
 
   const char* locationsSrc[] = { "jp", "al", "ro" };
 
@@ -131,7 +131,7 @@ void MetalinkEntryTest::testSetLocationPriority()
 
 void MetalinkEntryTest::testSetProtocolPriority()
 {
-  SharedHandle<MetalinkEntry> entry(createTestEntry());
+  std::shared_ptr<MetalinkEntry> entry(createTestEntry());
   entry->setProtocolPriority("http", -1);
   CPPUNIT_ASSERT_EQUAL(50, entry->resources[0]->priority); // ftp
   CPPUNIT_ASSERT_EQUAL(0, entry->resources[1]->priority); // http, -1
diff --git a/test/MetalinkHelperTest.cc b/test/MetalinkHelperTest.cc
index f79aa461..7fd78b5d 100644
--- a/test/MetalinkHelperTest.cc
+++ b/test/MetalinkHelperTest.cc
@@ -30,7 +30,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( MetalinkHelperTest );
 void MetalinkHelperTest::testParseAndQuery()
 {
   Option option;
-  std::vector<SharedHandle<MetalinkEntry> > result;
+  std::vector<std::shared_ptr<MetalinkEntry> > result;
   metalink::parseAndQuery(result, A2_TEST_DIR"/test.xml", &option);
   CPPUNIT_ASSERT_EQUAL((size_t)5, result.size());
 }
@@ -39,55 +39,55 @@ void MetalinkHelperTest::testParseAndQuery_version()
 {
   Option option;
   option.put(PREF_METALINK_VERSION, "0.5.1");
-  std::vector<SharedHandle<MetalinkEntry> > result;
+  std::vector<std::shared_ptr<MetalinkEntry> > result;
   metalink::parseAndQuery(result, A2_TEST_DIR"/test.xml", &option);
   CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
-  SharedHandle<MetalinkEntry> entry = result.front();
+  std::shared_ptr<MetalinkEntry> entry = result.front();
   CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.1.tar.bz2"), entry->getPath());
 }
 
 void MetalinkHelperTest::testGroupEntryByMetaurlName()
 {
-  std::vector<SharedHandle<MetalinkEntry> > entries;
+  std::vector<std::shared_ptr<MetalinkEntry> > entries;
 
-  SharedHandle<MetalinkEntry> e1(new MetalinkEntry());
+  std::shared_ptr<MetalinkEntry> e1(new MetalinkEntry());
   e1->version = "1";
   e1->sizeKnown = true;
   // no name
   e1->metaurls.push_back
-    (SharedHandle<MetalinkMetaurl>
+    (std::shared_ptr<MetalinkMetaurl>
      (new MetalinkMetaurl("http://meta1", "torrent", "", 1)));
 
-  SharedHandle<MetalinkEntry> e2(new MetalinkEntry());
+  std::shared_ptr<MetalinkEntry> e2(new MetalinkEntry());
   e2->version = "2";
   e2->sizeKnown = true;
 
-  SharedHandle<MetalinkEntry> e3(new MetalinkEntry());
+  std::shared_ptr<MetalinkEntry> e3(new MetalinkEntry());
   e3->version = "3";
   e3->sizeKnown = true;
   e3->metaurls.push_back
-    (SharedHandle<MetalinkMetaurl>
+    (std::shared_ptr<MetalinkMetaurl>
      (new MetalinkMetaurl("http://meta2", "torrent", "f3", 1)));
 
-  SharedHandle<MetalinkEntry> e4(new MetalinkEntry());
+  std::shared_ptr<MetalinkEntry> e4(new MetalinkEntry());
   e4->version = "4";
   e4->sizeKnown = true;
   e4->metaurls.push_back
-    (SharedHandle<MetalinkMetaurl>
+    (std::shared_ptr<MetalinkMetaurl>
      (new MetalinkMetaurl("http://meta1", "torrent", "f4", 1)));
 
-  SharedHandle<MetalinkEntry> e5(new MetalinkEntry());
+  std::shared_ptr<MetalinkEntry> e5(new MetalinkEntry());
   e5->version = "5";
   // no size
   e5->metaurls.push_back
-    (SharedHandle<MetalinkMetaurl>
+    (std::shared_ptr<MetalinkMetaurl>
      (new MetalinkMetaurl("http://meta1", "torrent", "f5", 1)));
 
-  SharedHandle<MetalinkEntry> e6(new MetalinkEntry());
+  std::shared_ptr<MetalinkEntry> e6(new MetalinkEntry());
   e6->version = "6";
   e6->sizeKnown = true;
   e6->metaurls.push_back
-    (SharedHandle<MetalinkMetaurl>
+    (std::shared_ptr<MetalinkMetaurl>
      (new MetalinkMetaurl("http://meta1", "torrent", "f6", 1)));
 
   entries.push_back(e1);
@@ -98,7 +98,7 @@ void MetalinkHelperTest::testGroupEntryByMetaurlName()
   entries.push_back(e6);
 
   std::vector<std::pair<std::string,
-    std::vector<SharedHandle<MetalinkEntry> > > > result;
+    std::vector<std::shared_ptr<MetalinkEntry> > > > result;
   metalink::groupEntryByMetaurlName(result, entries);
 
   CPPUNIT_ASSERT_EQUAL(std::string("http://meta1"), result[0].first);
diff --git a/test/MetalinkParserControllerTest.cc b/test/MetalinkParserControllerTest.cc
index 9b24e253..50829cb9 100644
--- a/test/MetalinkParserControllerTest.cc
+++ b/test/MetalinkParserControllerTest.cc
@@ -64,9 +64,9 @@ void MetalinkParserControllerTest::testEntryTransaction()
   ctrl.setOSOfEntry("Linux");
   ctrl.commitEntryTransaction();
   {
-    SharedHandle<Metalinker> m = ctrl.getResult();
+    std::shared_ptr<Metalinker> m = ctrl.getResult();
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size());
-    SharedHandle<MetalinkEntry> e = m->getEntries().front();
+    std::shared_ptr<MetalinkEntry> e = m->getEntries().front();
     CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), e->file->getPath());
     CPPUNIT_ASSERT_EQUAL((int64_t)(1024*1024LL), e->file->getLength());
     CPPUNIT_ASSERT_EQUAL((int64_t)0, e->file->getOffset());
@@ -91,9 +91,9 @@ void MetalinkParserControllerTest::testResourceTransaction()
   ctrl.setMaxConnectionsOfResource(1);
   ctrl.commitEntryTransaction();
   {
-    SharedHandle<Metalinker> m = ctrl.getResult();
+    std::shared_ptr<Metalinker> m = ctrl.getResult();
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().front()->resources.size());
-    SharedHandle<MetalinkResource> res = m->getEntries().front()->resources[0];
+    std::shared_ptr<MetalinkResource> res = m->getEntries().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(std::string("US"), res->location);
@@ -105,7 +105,7 @@ void MetalinkParserControllerTest::testResourceTransaction()
   ctrl.cancelResourceTransaction();
   ctrl.commitEntryTransaction();
   {
-    SharedHandle<Metalinker> m = ctrl.getResult();
+    std::shared_ptr<Metalinker> m = ctrl.getResult();
     CPPUNIT_ASSERT_EQUAL((size_t)2, m->getEntries().size());
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries()[0]->resources.size());
     CPPUNIT_ASSERT_EQUAL((size_t)0, m->getEntries()[1]->resources.size());
@@ -132,16 +132,16 @@ void MetalinkParserControllerTest::testResourceTransaction_withBaseUri()
 #endif // ENABLE_BITTORRENT
   ctrl.commitEntryTransaction();
   {
-    SharedHandle<Metalinker> m = ctrl.getResult();
+    std::shared_ptr<Metalinker> m = ctrl.getResult();
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries()[0]->resources.size());
-    SharedHandle<MetalinkResource> res = m->getEntries()[0]->resources[0];
+    std::shared_ptr<MetalinkResource> res = m->getEntries()[0]->resources[0];
     CPPUNIT_ASSERT_EQUAL(std::string("http://base/dir/aria2.tar.bz2"),
                          res->url);
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, res->type);
 
 #ifdef ENABLE_BITTORRENT
     CPPUNIT_ASSERT_EQUAL((size_t)2, m->getEntries()[0]->metaurls.size());
-    SharedHandle<MetalinkMetaurl> metaurl = m->getEntries()[0]->metaurls[0];
+    std::shared_ptr<MetalinkMetaurl> metaurl = m->getEntries()[0]->metaurls[0];
     CPPUNIT_ASSERT_EQUAL(std::string("http://base/meta/aria2.tar.bz2.torrent"),
                          metaurl->url);
 
@@ -164,10 +164,10 @@ void MetalinkParserControllerTest::testMetaurlTransaction()
   ctrl.commitEntryTransaction();
 #ifdef ENABLE_BITTORRENT
   {
-    SharedHandle<Metalinker> m = ctrl.getResult();
+    std::shared_ptr<Metalinker> m = ctrl.getResult();
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size());
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries()[0]->metaurls.size());
-    SharedHandle<MetalinkMetaurl> metaurl = m->getEntries()[0]->metaurls[0];
+    std::shared_ptr<MetalinkMetaurl> metaurl = m->getEntries()[0]->metaurls[0];
     CPPUNIT_ASSERT_EQUAL(std::string("http://example.org/chocolate.torrent"),
                          metaurl->url);
     CPPUNIT_ASSERT_EQUAL(std::string("torrent"), metaurl->mediatype);
@@ -179,14 +179,14 @@ void MetalinkParserControllerTest::testMetaurlTransaction()
   ctrl.cancelMetaurlTransaction();
   ctrl.commitEntryTransaction();
   {
-    SharedHandle<Metalinker> m = ctrl.getResult();
+    std::shared_ptr<Metalinker> m = ctrl.getResult();
     CPPUNIT_ASSERT_EQUAL((size_t)2, ctrl.getResult()->getEntries().size());
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries()[0]->metaurls.size());
     CPPUNIT_ASSERT_EQUAL((size_t)0, m->getEntries()[1]->metaurls.size());
   }
 #else // !ENABLE_BITTORRENT
   {
-    SharedHandle<Metalinker> m = ctrl.getResult();
+    std::shared_ptr<Metalinker> m = ctrl.getResult();
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size());
     CPPUNIT_ASSERT_EQUAL((size_t)0, m->getEntries()[0]->metaurls.size());
   }
@@ -203,8 +203,8 @@ void MetalinkParserControllerTest::testChecksumTransaction()
   ctrl.setHashOfChecksum("acbd18db4cc2f85cedef654fccc4a4d8");
   ctrl.commitEntryTransaction();
   {
-    SharedHandle<Metalinker> m = ctrl.getResult();
-    SharedHandle<Checksum> md = m->getEntries().front()->checksum;
+    std::shared_ptr<Metalinker> m = ctrl.getResult();
+    std::shared_ptr<Checksum> md = m->getEntries().front()->checksum;
     CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getHashType());
     CPPUNIT_ASSERT_EQUAL(std::string("acbd18db4cc2f85cedef654fccc4a4d8"),
                          util::toHex(md->getDigest()));
@@ -237,8 +237,8 @@ void MetalinkParserControllerTest::testChunkChecksumTransaction()
   ctrl.addHashOfChunkChecksum(5, "5cbd18db4cc2f85cedef654fccc4a4d8");
   ctrl.commitEntryTransaction();
   {
-    SharedHandle<Metalinker> m = ctrl.getResult();
-    SharedHandle<ChunkChecksum> md = m->getEntries().front()->chunkChecksum;
+    std::shared_ptr<Metalinker> m = ctrl.getResult();
+    std::shared_ptr<ChunkChecksum> md = m->getEntries().front()->chunkChecksum;
     CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getHashType());
     CPPUNIT_ASSERT_EQUAL(256*1024, md->getPieceLength());
     CPPUNIT_ASSERT_EQUAL((size_t)5, md->countPieceHash());
@@ -281,8 +281,8 @@ void MetalinkParserControllerTest::testChunkChecksumTransactionV4()
   ctrl.addHashOfChunkChecksumV4("44213f9f4d59b557314fadcd233232eebcac8012");
   ctrl.commitEntryTransaction();
   {
-    SharedHandle<Metalinker> m = ctrl.getResult();
-    SharedHandle<ChunkChecksum> md = m->getEntries().front()->chunkChecksum;
+    std::shared_ptr<Metalinker> m = ctrl.getResult();
+    std::shared_ptr<ChunkChecksum> md = m->getEntries().front()->chunkChecksum;
     CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), md->getHashType());
     CPPUNIT_ASSERT_EQUAL(256*1024, md->getPieceLength());
     CPPUNIT_ASSERT_EQUAL((size_t)3, md->countPieceHash());
@@ -334,9 +334,9 @@ void MetalinkParserControllerTest::testSignatureTransaction()
   // commitEntryTransaction also commits signature transaction.
   ctrl.commitEntryTransaction();
 
-  SharedHandle<Metalinker> m = ctrl.getResult();
+  std::shared_ptr<Metalinker> m = ctrl.getResult();
   CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size());
-  SharedHandle<Signature> sig = m->getEntries().front()->getSignature();
+  std::shared_ptr<Signature> sig = m->getEntries().front()->getSignature();
   CPPUNIT_ASSERT_EQUAL(std::string("pgp"), sig->getType());
   CPPUNIT_ASSERT_EQUAL(std::string("aria2.sig"), sig->getFile());
   CPPUNIT_ASSERT_EQUAL(pgpSignature, sig->getBody());
diff --git a/test/MetalinkPostDownloadHandlerTest.cc b/test/MetalinkPostDownloadHandlerTest.cc
index 1447b1bf..9d4c955c 100644
--- a/test/MetalinkPostDownloadHandlerTest.cc
+++ b/test/MetalinkPostDownloadHandlerTest.cc
@@ -20,7 +20,7 @@ class MetalinkPostDownloadHandlerTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testGetNextRequestGroups_withBaseUri);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<Option> option_;
+  std::shared_ptr<Option> option_;
 public:
   void setUp()
   {
@@ -38,7 +38,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( MetalinkPostDownloadHandlerTest );
 
 void MetalinkPostDownloadHandlerTest::testCanHandle_extension()
 {
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(0, 0, "test.metalink"));
   RequestGroup rg(GroupId::create(), option_);
   rg.setDownloadContext(dctx);
@@ -53,7 +53,7 @@ void MetalinkPostDownloadHandlerTest::testCanHandle_extension()
 
 void MetalinkPostDownloadHandlerTest::testCanHandle_contentType()
 {
-  SharedHandle<DownloadContext> dctx(new DownloadContext(0, 0, "test"));
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext(0, 0, "test"));
   dctx->getFirstFileEntry()->setContentType("application/metalink+xml");
   RequestGroup rg(GroupId::create(), option_);
   rg.setDownloadContext(dctx);
@@ -68,7 +68,7 @@ void MetalinkPostDownloadHandlerTest::testCanHandle_contentType()
 
 void MetalinkPostDownloadHandlerTest::testGetNextRequestGroups()
 {
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(1024, 0, A2_TEST_DIR"/test.xml"));
   RequestGroup rg(GroupId::create(), option_);
   rg.setDownloadContext(dctx);
@@ -76,7 +76,7 @@ void MetalinkPostDownloadHandlerTest::testGetNextRequestGroups()
   rg.getPieceStorage()->getDiskAdaptor()->enableReadOnly();
 
   MetalinkPostDownloadHandler handler;
-  std::vector<SharedHandle<RequestGroup> > groups;
+  std::vector<std::shared_ptr<RequestGroup> > groups;
   handler.getNextRequestGroups(groups, &rg);
 #ifdef ENABLE_BITTORRENT
   CPPUNIT_ASSERT_EQUAL((size_t)6/* 5 + 1 torrent file download */, groups.size());
@@ -87,7 +87,7 @@ void MetalinkPostDownloadHandlerTest::testGetNextRequestGroups()
 
 void MetalinkPostDownloadHandlerTest::testGetNextRequestGroups_withBaseUri()
 {
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(1024, 0, A2_TEST_DIR"/base_uri.xml"));
   dctx->getFirstFileEntry()->addUri("http://base/dir/base_uri.xml");
   RequestGroup rg(GroupId::create(), option_);
@@ -96,7 +96,7 @@ void MetalinkPostDownloadHandlerTest::testGetNextRequestGroups_withBaseUri()
   rg.getPieceStorage()->getDiskAdaptor()->enableReadOnly();
 
   MetalinkPostDownloadHandler handler;
-  std::vector<SharedHandle<RequestGroup> > groups;
+  std::vector<std::shared_ptr<RequestGroup> > groups;
   handler.getNextRequestGroups(groups, &rg);
   CPPUNIT_ASSERT_EQUAL((size_t)1, groups.size());
   CPPUNIT_ASSERT_EQUAL(std::string("http://base/dir/example.ext"),
diff --git a/test/MetalinkProcessorTest.cc b/test/MetalinkProcessorTest.cc
index 9f885504..c74048a1 100644
--- a/test/MetalinkProcessorTest.cc
+++ b/test/MetalinkProcessorTest.cc
@@ -82,10 +82,10 @@ CPPUNIT_TEST_SUITE_REGISTRATION( MetalinkProcessorTest );
 
 void MetalinkProcessorTest::testParseFileV4()
 {
-  SharedHandle<Metalinker> m = metalink::parseFile(A2_TEST_DIR"/metalink4.xml");
-  SharedHandle<MetalinkEntry> e;
-  SharedHandle<MetalinkResource> r;
-  SharedHandle<MetalinkMetaurl> mu;
+  std::shared_ptr<Metalinker> m = metalink::parseFile(A2_TEST_DIR"/metalink4.xml");
+  std::shared_ptr<MetalinkEntry> e;
+  std::shared_ptr<MetalinkResource> r;
+  std::shared_ptr<MetalinkMetaurl> mu;
   CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size());
   e = m->getEntries()[0];
   CPPUNIT_ASSERT_EQUAL(std::string("example.ext"), e->getPath());
@@ -151,7 +151,7 @@ void MetalinkProcessorTest::testParseFileV4()
 
 void MetalinkProcessorTest::testParseFileV4_attrs()
 {
-  SharedHandle<Metalinker> m;
+  std::shared_ptr<Metalinker> m;
   ByteArrayDiskWriter dw;
   {
     // Testing file@name
@@ -492,13 +492,13 @@ void MetalinkProcessorTest::testParseFileV4_attrs()
 void MetalinkProcessorTest::testParseFile()
 {
   try {
-    SharedHandle<Metalinker> metalinker =
+    std::shared_ptr<Metalinker> metalinker =
       metalink::parseFile(A2_TEST_DIR"/test.xml");
 
-    std::vector<SharedHandle<MetalinkEntry> >::const_iterator entryItr =
+    std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator entryItr =
       metalinker->getEntries().begin();
 
-    SharedHandle<MetalinkEntry> entry1 = *entryItr;
+    std::shared_ptr<MetalinkEntry> entry1 = *entryItr;
     CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), entry1->getPath());
     CPPUNIT_ASSERT_EQUAL((int64_t)0LL, entry1->getLength());
     CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), entry1->version);
@@ -527,9 +527,9 @@ void MetalinkProcessorTest::testParseFile()
         "\t"),
        entry1->getSignature()->getBody());
 
-    std::vector<SharedHandle<MetalinkResource> >::iterator resourceItr1 =
+    std::vector<std::shared_ptr<MetalinkResource> >::iterator resourceItr1 =
       entry1->resources.begin();
-    SharedHandle<MetalinkResource> resource1 = *resourceItr1;
+    std::shared_ptr<MetalinkResource> resource1 = *resourceItr1;
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, resource1->type);
     CPPUNIT_ASSERT_EQUAL(std::string("jp"), resource1->location);
     CPPUNIT_ASSERT_EQUAL(1, resource1->priority);
@@ -538,7 +538,7 @@ void MetalinkProcessorTest::testParseFile()
     CPPUNIT_ASSERT_EQUAL(1, resource1->maxConnections);
 
     resourceItr1++;
-    SharedHandle<MetalinkResource> resource2 = *resourceItr1;
+    std::shared_ptr<MetalinkResource> resource2 = *resourceItr1;
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, resource2->type);
     CPPUNIT_ASSERT_EQUAL(std::string("us"), resource2->location);
     CPPUNIT_ASSERT_EQUAL(1, resource2->priority);
@@ -548,7 +548,7 @@ void MetalinkProcessorTest::testParseFile()
 
     entryItr++;
 
-    SharedHandle<MetalinkEntry> entry2 = *entryItr;
+    std::shared_ptr<MetalinkEntry> entry2 = *entryItr;
     CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.1.tar.bz2"), entry2->getPath());
     CPPUNIT_ASSERT_EQUAL((int64_t)345689LL, entry2->getLength());
     CPPUNIT_ASSERT_EQUAL(std::string("0.5.1"), entry2->version);
@@ -572,7 +572,7 @@ void MetalinkProcessorTest::testParseFile()
     entryItr++;
 
     // test case: verification hash is not provided
-    SharedHandle<MetalinkEntry> entry3 = *entryItr;
+    std::shared_ptr<MetalinkEntry> entry3 = *entryItr;
     CPPUNIT_ASSERT_EQUAL(std::string("NoVerificationHash"), entry3->getPath());
 #ifdef ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT(!entry3->checksum);
@@ -582,7 +582,7 @@ void MetalinkProcessorTest::testParseFile()
     entryItr++;
 
     // test case: unsupported verification hash is included
-    SharedHandle<MetalinkEntry> entry4 = *entryItr;
+    std::shared_ptr<MetalinkEntry> entry4 = *entryItr;
     CPPUNIT_ASSERT_EQUAL(std::string("UnsupportedVerificationHashTypeIncluded"), entry4->getPath());
 #ifdef ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry4->checksum->getHashType());
@@ -599,10 +599,10 @@ void MetalinkProcessorTest::testParseFile()
 
 void MetalinkProcessorTest::testParseFile_dirtraversal()
 {
-  SharedHandle<Metalinker> metalinker =
+  std::shared_ptr<Metalinker> metalinker =
     metalink::parseFile(A2_TEST_DIR"/metalink3-dirtraversal.xml");
   CPPUNIT_ASSERT_EQUAL((size_t)1, metalinker->getEntries().size());
-  SharedHandle<MetalinkEntry> e = metalinker->getEntries()[0];
+  std::shared_ptr<MetalinkEntry> e = metalinker->getEntries()[0];
   CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.3.tar.bz2"), e->getPath());
   CPPUNIT_ASSERT(e->getSignature());
   CPPUNIT_ASSERT_EQUAL(std::string(""), e->getSignature()->getFile());
@@ -615,11 +615,11 @@ void MetalinkProcessorTest::testParseBinaryStream()
   dw.openExistingFile();
 
   try {
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
 
-    std::vector<SharedHandle<MetalinkEntry> >::const_iterator entryItr =
+    std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator entryItr =
       m->getEntries().begin();
-    SharedHandle<MetalinkEntry> entry1 = *entryItr;
+    std::shared_ptr<MetalinkEntry> entry1 = *entryItr;
     CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), entry1->getPath());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
@@ -632,7 +632,7 @@ void MetalinkProcessorTest::testMalformedXML()
   dw.setString("<metalink version=\"3.0\" xmlns=\"http://www.metalinker.org/\"><files></file></metalink>");
 
   try {
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception& e) {
     std::cerr << e.stackTrace() << std::endl;
@@ -645,7 +645,7 @@ void MetalinkProcessorTest::testMalformedXML2()
   dw.setString("<metalink version=\"3.0\" xmlns=\"http://www.metalinker.org/\"><files></files>");
 
   try {
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception& e) {
     std::cerr << e.stackTrace() << std::endl;
@@ -654,7 +654,7 @@ void MetalinkProcessorTest::testMalformedXML2()
 
 void MetalinkProcessorTest::testBadSizeV4()
 {
-  SharedHandle<Metalinker> m;
+  std::shared_ptr<Metalinker> m;
   ByteArrayDiskWriter dw;
 
   const char* tmpl =
@@ -691,11 +691,11 @@ void MetalinkProcessorTest::testBadSize()
                 "</metalink>");
 
   try {
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
 
-    std::vector<SharedHandle<MetalinkEntry> >::const_iterator entryItr =
+    std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator entryItr =
       m->getEntries().begin();
-    SharedHandle<MetalinkEntry> e = *entryItr;
+    std::shared_ptr<MetalinkEntry> e = *entryItr;
     CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), e->getPath());
     CPPUNIT_ASSERT_EQUAL((int64_t)0LL, e->getLength());
     CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), e->version);
@@ -723,11 +723,11 @@ void MetalinkProcessorTest::testBadMaxConn()
                 "</metalink>");
 
   try {
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
 
-    std::vector<SharedHandle<MetalinkEntry> >::const_iterator entryItr =
+    std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator entryItr =
       m->getEntries().begin();
-    SharedHandle<MetalinkEntry> e = *entryItr;
+    std::shared_ptr<MetalinkEntry> e = *entryItr;
     CPPUNIT_ASSERT_EQUAL((int64_t)43743838LL, e->getLength());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
@@ -755,11 +755,11 @@ void MetalinkProcessorTest::testNoName()
                 "</metalink>");
 
   try {
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size());
-    std::vector<SharedHandle<MetalinkEntry> >::const_iterator entryItr =
+    std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator entryItr =
       m->getEntries().begin();
-    SharedHandle<MetalinkEntry> e = *entryItr;
+    std::shared_ptr<MetalinkEntry> e = *entryItr;
     CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), e->getPath());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
@@ -785,9 +785,9 @@ void MetalinkProcessorTest::testBadURLPrefs()
                 "</metalink>");
 
   try {
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
-    SharedHandle<MetalinkEntry> e = m->getEntries()[0];
-    SharedHandle<MetalinkResource> r = e->resources[0];
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<MetalinkEntry> e = m->getEntries()[0];
+    std::shared_ptr<MetalinkResource> r = e->resources[0];
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, r->type);
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::getLowestPriority(), r->priority);
     CPPUNIT_ASSERT_EQUAL(1, r->maxConnections);
@@ -817,9 +817,9 @@ void MetalinkProcessorTest::testBadURLMaxConn()
                 "</metalink>");
 
   try {
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
-    SharedHandle<MetalinkEntry> e = m->getEntries()[0];
-    SharedHandle<MetalinkResource> r = e->resources[0];
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<MetalinkEntry> e = m->getEntries()[0];
+    std::shared_ptr<MetalinkResource> r = e->resources[0];
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, r->type);
     CPPUNIT_ASSERT_EQUAL(1, r->priority);
     CPPUNIT_ASSERT_EQUAL(-1, r->maxConnections);
@@ -850,14 +850,14 @@ void MetalinkProcessorTest::testUnsupportedType()
                 "</metalink>");
 
   try {
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
-    SharedHandle<MetalinkEntry> e = m->getEntries()[0];
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<MetalinkEntry> e = m->getEntries()[0];
     CPPUNIT_ASSERT_EQUAL((size_t)3, e->resources.size());
-    SharedHandle<MetalinkResource> r1 = e->resources[0];
+    std::shared_ptr<MetalinkResource> r1 = e->resources[0];
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, r1->type);
-    SharedHandle<MetalinkResource> r2 = e->resources[1];
+    std::shared_ptr<MetalinkResource> r2 = e->resources[1];
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_NOT_SUPPORTED, r2->type);
-    SharedHandle<MetalinkResource> r3 = e->resources[2];
+    std::shared_ptr<MetalinkResource> r3 = e->resources[2];
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, r3->type);
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
@@ -882,9 +882,9 @@ void MetalinkProcessorTest::testMultiplePieces()
 
   try {
     // aria2 prefers sha1
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
-    SharedHandle<MetalinkEntry> e = m->getEntries()[0];
-    SharedHandle<ChunkChecksum> c = e->chunkChecksum;
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<MetalinkEntry> e = m->getEntries()[0];
+    std::shared_ptr<ChunkChecksum> c = e->chunkChecksum;
 
     CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType());
     CPPUNIT_ASSERT_EQUAL(1024, c->getPieceLength());
@@ -914,9 +914,9 @@ void MetalinkProcessorTest::testBadPieceNo()
      "</metalink>");
 
   try {
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
-    SharedHandle<MetalinkEntry> e = m->getEntries()[0];
-    SharedHandle<ChunkChecksum> c = e->chunkChecksum;
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<MetalinkEntry> e = m->getEntries()[0];
+    std::shared_ptr<ChunkChecksum> c = e->chunkChecksum;
 
     CPPUNIT_ASSERT(c);
     CPPUNIT_ASSERT_EQUAL(1024, c->getPieceLength());
@@ -946,10 +946,10 @@ void MetalinkProcessorTest::testBadPieceLength()
      "</metalink>");
 
   try {
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size());
-    SharedHandle<MetalinkEntry> e = m->getEntries()[0];
-    SharedHandle<ChunkChecksum> c = e->chunkChecksum;
+    std::shared_ptr<MetalinkEntry> e = m->getEntries()[0];
+    std::shared_ptr<ChunkChecksum> c = e->chunkChecksum;
     CPPUNIT_ASSERT(c);
     CPPUNIT_ASSERT_EQUAL(1024, c->getPieceLength());
     CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType());
@@ -978,9 +978,9 @@ void MetalinkProcessorTest::testUnsupportedType_piece()
      "</metalink>");
 
   try {
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
-    SharedHandle<MetalinkEntry> e = m->getEntries()[0];
-    SharedHandle<ChunkChecksum> c = e->chunkChecksum;
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<MetalinkEntry> e = m->getEntries()[0];
+    std::shared_ptr<ChunkChecksum> c = e->chunkChecksum;
 
     CPPUNIT_ASSERT(c);
     CPPUNIT_ASSERT_EQUAL(1024, c->getPieceLength());
@@ -1006,8 +1006,8 @@ void MetalinkProcessorTest::testLargeFileSize()
      "</files>"
      "</metalink>");
   try {
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
-    SharedHandle<MetalinkEntry> e = m->getEntries()[0];
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<MetalinkEntry> e = m->getEntries()[0];
     CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775807LL, e->getLength());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
@@ -1029,9 +1029,9 @@ void MetalinkProcessorTest::testXmlPrefixV3()
                 "</m:metalink>");
 
   try {
-    SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
+    std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw);
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size());
-    SharedHandle<MetalinkEntry> e = m->getEntries()[0];
+    std::shared_ptr<MetalinkEntry> e = m->getEntries()[0];
     CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775807LL, e->getLength());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
diff --git a/test/MetalinkerTest.cc b/test/MetalinkerTest.cc
index cab53370..e0584846 100644
--- a/test/MetalinkerTest.cc
+++ b/test/MetalinkerTest.cc
@@ -26,12 +26,12 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION( MetalinkerTest );
 
 void MetalinkerTest::testQueryEntry() {
-  SharedHandle<Metalinker> metalinker(new Metalinker());
-  SharedHandle<MetalinkEntry> entry1(new MetalinkEntry());
+  std::shared_ptr<Metalinker> metalinker(new Metalinker());
+  std::shared_ptr<MetalinkEntry> entry1(new MetalinkEntry());
   entry1->version = "0.5.2";
   entry1->languages.push_back("en-US");
   entry1->oses.push_back("Linux-x86");
-  SharedHandle<MetalinkEntry> entry2(new MetalinkEntry());
+  std::shared_ptr<MetalinkEntry> entry2(new MetalinkEntry());
   entry2->version = "0.5.1";
   entry2->languages.push_back("ja-JP");
   entry2->oses.push_back("Linux-m68k");
@@ -46,7 +46,7 @@ void MetalinkerTest::testQueryEntry() {
   language = "ja-JP";
   os = "Linux-m68k";
   {
-    std::vector<SharedHandle<MetalinkEntry> > result;
+    std::vector<std::shared_ptr<MetalinkEntry> > result;
     metalinker->queryEntry(result, version, language, os);
     CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
     CPPUNIT_ASSERT_EQUAL(std::string("0.5.1"), result.at(0)->version);
@@ -57,7 +57,7 @@ void MetalinkerTest::testQueryEntry() {
   language = "";
   os = "";
   {
-    std::vector<SharedHandle<MetalinkEntry> > result;
+    std::vector<std::shared_ptr<MetalinkEntry> > result;
     metalinker->queryEntry(result, version, language, os);
     CPPUNIT_ASSERT_EQUAL((size_t)0, result.size());
   }
@@ -66,7 +66,7 @@ void MetalinkerTest::testQueryEntry() {
   language = "";
   os = "";
   {
-    std::vector<SharedHandle<MetalinkEntry> > result;
+    std::vector<std::shared_ptr<MetalinkEntry> > result;
     metalinker->queryEntry(result, version, language, os);
     CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
     CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), result.at(0)->version);
diff --git a/test/MockBtAnnounce.h b/test/MockBtAnnounce.h
index 1236c8c2..e1b00f27 100644
--- a/test/MockBtAnnounce.h
+++ b/test/MockBtAnnounce.h
@@ -26,10 +26,10 @@ public:
     return announceUrl;
   }
 
-  virtual SharedHandle<UDPTrackerRequest>
+  virtual std::shared_ptr<UDPTrackerRequest>
   createUDPTrackerRequest(const std::string& remoteAddr, uint16_t remotePort,
                           uint16_t localPort) {
-    return SharedHandle<UDPTrackerRequest>();
+    return std::shared_ptr<UDPTrackerRequest>();
   }
 
   void setAnnounceUrl(const std::string& url) {
@@ -52,7 +52,7 @@ public:
                                        size_t trackerResponseLength) {}
 
   virtual void processUDPTrackerResponse
-  (const SharedHandle<UDPTrackerRequest>& req) {}
+  (const std::shared_ptr<UDPTrackerRequest>& req) {}
 
   virtual bool noMoreAnnounce() {
     return false;
diff --git a/test/MockBtMessage.h b/test/MockBtMessage.h
index 37625a0f..1de8f223 100644
--- a/test/MockBtMessage.h
+++ b/test/MockBtMessage.h
@@ -90,9 +90,9 @@ public:
 template<typename T>
 class WrapBtMessage:public MockBtMessage {
 public:
-  SharedHandle<T> m_;
+  std::shared_ptr<T> m_;
 
-  WrapBtMessage(const SharedHandle<T>& m):m_(m) {}
+  WrapBtMessage(const std::shared_ptr<T>& m):m_(m) {}
 };
 
 
diff --git a/test/MockBtMessageDispatcher.h b/test/MockBtMessageDispatcher.h
index 4c3cf17c..f505d98f 100644
--- a/test/MockBtMessageDispatcher.h
+++ b/test/MockBtMessageDispatcher.h
@@ -12,16 +12,16 @@ namespace aria2 {
 
 class MockBtMessageDispatcher : public BtMessageDispatcher {
 public:
-  std::deque<SharedHandle<BtMessage> > messageQueue;
+  std::deque<std::shared_ptr<BtMessage> > messageQueue;
 
   virtual ~MockBtMessageDispatcher() {}
 
-  virtual void addMessageToQueue(const SharedHandle<BtMessage>& btMessage) {
+  virtual void addMessageToQueue(const std::shared_ptr<BtMessage>& btMessage) {
     messageQueue.push_back(btMessage);
   }
 
   virtual void addMessageToQueue
-  (const std::vector<SharedHandle<BtMessage> >& btMessages)
+  (const std::vector<std::shared_ptr<BtMessage> >& btMessages)
   {
     std::copy(btMessages.begin(), btMessages.end(), back_inserter(messageQueue));
   }
@@ -31,9 +31,9 @@ public:
   virtual void doCancelSendingPieceAction
   (size_t index, int32_t begin, int32_t length) {}
 
-  virtual void doCancelSendingPieceAction(const SharedHandle<Piece>& piece) {}
+  virtual void doCancelSendingPieceAction(const std::shared_ptr<Piece>& piece) {}
 
-  virtual void doAbortOutstandingRequestAction(const SharedHandle<Piece>& piece) {}
+  virtual void doAbortOutstandingRequestAction(const std::shared_ptr<Piece>& piece) {}
 
   virtual void doChokedAction() {}
 
diff --git a/test/MockBtMessageFactory.h b/test/MockBtMessageFactory.h
index a482835d..79c035bd 100644
--- a/test/MockBtMessageFactory.h
+++ b/test/MockBtMessageFactory.h
@@ -13,91 +13,91 @@ public:
 
   virtual ~MockBtMessageFactory() {}
 
-  virtual SharedHandle<BtMessage>
+  virtual std::shared_ptr<BtMessage>
   createBtMessage(const unsigned char* msg, size_t msgLength) {
-    return SharedHandle<BtMessage>();
+    return std::shared_ptr<BtMessage>();
   };
 
-  virtual SharedHandle<BtHandshakeMessage>
+  virtual std::shared_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* msg, size_t msgLength) {
-    return SharedHandle<BtHandshakeMessage>();
+    return std::shared_ptr<BtHandshakeMessage>();
   }
 
-  virtual SharedHandle<BtHandshakeMessage>
+  virtual std::shared_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* infoHash,
                          const unsigned char* peerId) {
-    return SharedHandle<BtHandshakeMessage>();
+    return std::shared_ptr<BtHandshakeMessage>();
   }
 
-  virtual SharedHandle<BtMessage>
-  createRequestMessage(const SharedHandle<Piece>& piece, size_t blockIndex) {
-    return SharedHandle<BtMessage>();
+  virtual std::shared_ptr<BtMessage>
+  createRequestMessage(const std::shared_ptr<Piece>& piece, size_t blockIndex) {
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage>
+  virtual std::shared_ptr<BtMessage>
   createCancelMessage(size_t index, int32_t begin, int32_t length) {
-    return SharedHandle<BtMessage>();
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage>
+  virtual std::shared_ptr<BtMessage>
   createPieceMessage(size_t index, int32_t begin, int32_t length) {
-    return SharedHandle<BtMessage>();
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage> createHaveMessage(size_t index) {
-    return SharedHandle<BtMessage>();
+  virtual std::shared_ptr<BtMessage> createHaveMessage(size_t index) {
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage> createChokeMessage() {
-    return SharedHandle<BtMessage>();
+  virtual std::shared_ptr<BtMessage> createChokeMessage() {
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage> createUnchokeMessage() {
-    return SharedHandle<BtMessage>();
+  virtual std::shared_ptr<BtMessage> createUnchokeMessage() {
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage> createInterestedMessage() {
-    return SharedHandle<BtMessage>();
+  virtual std::shared_ptr<BtMessage> createInterestedMessage() {
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage> createNotInterestedMessage() {
-    return SharedHandle<BtMessage>();
+  virtual std::shared_ptr<BtMessage> createNotInterestedMessage() {
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage> createBitfieldMessage() {
-    return SharedHandle<BtMessage>();
+  virtual std::shared_ptr<BtMessage> createBitfieldMessage() {
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage> createKeepAliveMessage() {
-    return SharedHandle<BtMessage>();
+  virtual std::shared_ptr<BtMessage> createKeepAliveMessage() {
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage> createHaveAllMessage() {
-    return SharedHandle<BtMessage>();
+  virtual std::shared_ptr<BtMessage> createHaveAllMessage() {
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage> createHaveNoneMessage() {
-    return SharedHandle<BtMessage>();
+  virtual std::shared_ptr<BtMessage> createHaveNoneMessage() {
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage>
+  virtual std::shared_ptr<BtMessage>
   createRejectMessage(size_t index, int32_t begin, int32_t length) {
-    return SharedHandle<BtMessage>();
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage> createAllowedFastMessage(size_t index) {
-    return SharedHandle<BtMessage>();
+  virtual std::shared_ptr<BtMessage> createAllowedFastMessage(size_t index) {
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage> createPortMessage(uint16_t port)
+  virtual std::shared_ptr<BtMessage> createPortMessage(uint16_t port)
   {
-    return SharedHandle<BtMessage>();
+    return std::shared_ptr<BtMessage>();
   }
 
-  virtual SharedHandle<BtMessage>
-  createBtExtendedMessage(const SharedHandle<ExtensionMessage>& extmsg)
+  virtual std::shared_ptr<BtMessage>
+  createBtExtendedMessage(const std::shared_ptr<ExtensionMessage>& extmsg)
   {
-    return SharedHandle<BtMessage>();
+    return std::shared_ptr<BtMessage>();
   }
 };
 
diff --git a/test/MockBtRequestFactory.h b/test/MockBtRequestFactory.h
index 5dbf37ca..ff198155 100644
--- a/test/MockBtRequestFactory.h
+++ b/test/MockBtRequestFactory.h
@@ -9,9 +9,9 @@ class MockBtRequestFactory : public BtRequestFactory {
 public:
   virtual ~MockBtRequestFactory() {}
 
-  virtual void addTargetPiece(const SharedHandle<Piece>& piece) {}
+  virtual void addTargetPiece(const std::shared_ptr<Piece>& piece) {}
 
-  virtual void removeTargetPiece(const SharedHandle<Piece>& piece) {}
+  virtual void removeTargetPiece(const std::shared_ptr<Piece>& piece) {}
 
   virtual void removeAllTargetPiece() {}
 
@@ -24,10 +24,10 @@ public:
   virtual void doChokedAction() {}
 
   virtual void createRequestMessages
-  (std::vector<SharedHandle<BtMessage> >& requests, size_t max) {}
+  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max) {}
 
   virtual void createRequestMessagesOnEndGame
-  (std::vector<SharedHandle<BtMessage> >& requests, size_t max) {}
+  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max) {}
 
   virtual void getTargetPieceIndexes(std::vector<size_t>& indexes) const {}
 };
diff --git a/test/MockDHTMessage.h b/test/MockDHTMessage.h
index d402d637..8fb9fd82 100644
--- a/test/MockDHTMessage.h
+++ b/test/MockDHTMessage.h
@@ -20,14 +20,14 @@ public:
 
   std::string messageType_;
 
-  std::vector<SharedHandle<DHTNode> > nodes_;
+  std::vector<std::shared_ptr<DHTNode> > nodes_;
 
-  std::vector<SharedHandle<Peer> > peers_;
+  std::vector<std::shared_ptr<Peer> > peers_;
 
   std::string token_;
 public:
-  MockDHTMessage(const SharedHandle<DHTNode>& localNode,
-                 const SharedHandle<DHTNode>& remoteNode,
+  MockDHTMessage(const std::shared_ptr<DHTNode>& localNode,
+                 const std::shared_ptr<DHTNode>& remoteNode,
                  const std::string& messageType = "mock",
                  const std::string& transactionID = ""):
     DHTMessage(localNode, remoteNode, transactionID), isReply_(false), messageType_(messageType) {}
@@ -51,14 +51,14 @@ class MockDHTQueryMessage:public DHTQueryMessage {
 public:
   std::string messageType_;
 
-  std::vector<SharedHandle<DHTNode> > nodes_;
+  std::vector<std::shared_ptr<DHTNode> > nodes_;
 
-  std::vector<SharedHandle<Peer> > peers_;
+  std::vector<std::shared_ptr<Peer> > peers_;
 
   std::string token_;
 public:
-  MockDHTQueryMessage(const SharedHandle<DHTNode>& localNode,
-                      const SharedHandle<DHTNode>& remoteNode,
+  MockDHTQueryMessage(const std::shared_ptr<DHTNode>& localNode,
+                      const std::shared_ptr<DHTNode>& remoteNode,
                       const std::string& messageType = "mock",
                       const std::string& transactionID = ""):
     DHTQueryMessage(localNode, remoteNode, transactionID),
@@ -76,21 +76,21 @@ public:
 
   virtual std::string toString() const { return "MockDHTMessage"; }
 
-  virtual SharedHandle<Dict> getArgument() { return Dict::g(); }
+  virtual std::shared_ptr<Dict> getArgument() { return Dict::g(); }
 };
 
 class MockDHTResponseMessage:public DHTResponseMessage {
 public:
   std::string messageType_;
 
-  std::vector<SharedHandle<DHTNode> > nodes_;
+  std::vector<std::shared_ptr<DHTNode> > nodes_;
 
-  std::vector<SharedHandle<Peer> > peers_;
+  std::vector<std::shared_ptr<Peer> > peers_;
 
   std::string token_;
 public:
-  MockDHTResponseMessage(const SharedHandle<DHTNode>& localNode,
-                         const SharedHandle<DHTNode>& remoteNode,
+  MockDHTResponseMessage(const std::shared_ptr<DHTNode>& localNode,
+                         const std::shared_ptr<DHTNode>& remoteNode,
                          const std::string& messageType = "mock",
                          const std::string& transactionID = ""):
     DHTResponseMessage(localNode, remoteNode, transactionID),
@@ -108,7 +108,7 @@ public:
 
   virtual std::string toString() const { return "MockDHTMessage"; }
 
-  virtual SharedHandle<Dict> getResponse() { return Dict::g(); }
+  virtual std::shared_ptr<Dict> getResponse() { return Dict::g(); }
 
   virtual void accept(DHTMessageCallback* callback) {}
 };
diff --git a/test/MockDHTMessageCallback.h b/test/MockDHTMessageCallback.h
index 79eb17d1..ed574771 100644
--- a/test/MockDHTMessageCallback.h
+++ b/test/MockDHTMessageCallback.h
@@ -19,7 +19,7 @@ public:
 
   virtual void visit(const DHTPingReplyMessage* message) {}
 
-  virtual void onTimeout(const SharedHandle<DHTNode>& remoteNode) {}
+  virtual void onTimeout(const std::shared_ptr<DHTNode>& remoteNode) {}
 };
 
 } // namespace aria2
diff --git a/test/MockDHTMessageDispatcher.h b/test/MockDHTMessageDispatcher.h
index 5e930758..214d7c38 100644
--- a/test/MockDHTMessageDispatcher.h
+++ b/test/MockDHTMessageDispatcher.h
@@ -12,12 +12,12 @@ class MockDHTMessageDispatcher:public DHTMessageDispatcher {
 public:
   class Entry {
   public:
-    SharedHandle<DHTMessage> message_;
+    std::shared_ptr<DHTMessage> message_;
     time_t timeout_;
-    SharedHandle<DHTMessageCallback> callback_;
+    std::shared_ptr<DHTMessageCallback> callback_;
 
-    Entry(const SharedHandle<DHTMessage>& message, time_t timeout,
-          const SharedHandle<DHTMessageCallback>& callback):
+    Entry(const std::shared_ptr<DHTMessage>& message, time_t timeout,
+          const std::shared_ptr<DHTMessageCallback>& callback):
       message_(message),
       timeout_(timeout),
       callback_(callback) {}
@@ -31,18 +31,18 @@ public:
   virtual ~MockDHTMessageDispatcher() {}
 
   virtual void
-  addMessageToQueue(const SharedHandle<DHTMessage>& message,
+  addMessageToQueue(const std::shared_ptr<DHTMessage>& message,
                     time_t timeout,
-                    const SharedHandle<DHTMessageCallback>& callback =
-                    SharedHandle<DHTMessageCallback>())
+                    const std::shared_ptr<DHTMessageCallback>& callback =
+                    std::shared_ptr<DHTMessageCallback>())
   {
     messageQueue_.push_back(Entry(message, timeout, callback));
   }
 
   virtual void
-  addMessageToQueue(const SharedHandle<DHTMessage>& message,
-                    const SharedHandle<DHTMessageCallback>& callback =
-                    SharedHandle<DHTMessageCallback>())
+  addMessageToQueue(const std::shared_ptr<DHTMessage>& message,
+                    const std::shared_ptr<DHTMessageCallback>& callback =
+                    std::shared_ptr<DHTMessageCallback>())
   {
     messageQueue_.push_back(Entry(message, DHT_MESSAGE_TIMEOUT, callback));
   }
diff --git a/test/MockDHTMessageFactory.h b/test/MockDHTMessageFactory.h
index d1e8c766..aa5efcaf 100644
--- a/test/MockDHTMessageFactory.h
+++ b/test/MockDHTMessageFactory.h
@@ -9,110 +9,110 @@ namespace aria2 {
 
 class MockDHTMessageFactory:public DHTMessageFactory {
 protected:
-  SharedHandle<DHTNode> localNode_;
+  std::shared_ptr<DHTNode> localNode_;
 public:
   MockDHTMessageFactory() {}
 
   virtual ~MockDHTMessageFactory() {}
 
-  virtual SharedHandle<DHTQueryMessage>
+  virtual std::shared_ptr<DHTQueryMessage>
   createQueryMessage(const Dict* dict,
                      const std::string& ipaddr, uint16_t port)
   {
-    return SharedHandle<DHTQueryMessage>();
+    return std::shared_ptr<DHTQueryMessage>();
   }
 
-  virtual SharedHandle<DHTResponseMessage>
+  virtual std::shared_ptr<DHTResponseMessage>
   createResponseMessage(const std::string& messageType,
                         const Dict* dict,
                         const std::string& ipaddr, uint16_t port)
   {
-    SharedHandle<DHTNode> remoteNode(new DHTNode());
+    std::shared_ptr<DHTNode> remoteNode(new DHTNode());
     // TODO At this point, removeNode's ID is random.
     remoteNode->setIPAddress(ipaddr);
     remoteNode->setPort(port);
-    SharedHandle<MockDHTResponseMessage> m
+    std::shared_ptr<MockDHTResponseMessage> m
       (new MockDHTResponseMessage(localNode_, remoteNode,
                                   downcast<String>(dict->get("t"))->s()));
     return m;
   }
 
-  virtual SharedHandle<DHTQueryMessage>
-  createPingMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTQueryMessage>
+  createPingMessage(const std::shared_ptr<DHTNode>& remoteNode,
                     const std::string& transactionID = "")
   {
-    return SharedHandle<DHTQueryMessage>();
+    return std::shared_ptr<DHTQueryMessage>();
   }
 
-  virtual SharedHandle<DHTResponseMessage>
-  createPingReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTResponseMessage>
+  createPingReplyMessage(const std::shared_ptr<DHTNode>& remoteNode,
                          const unsigned char* remoteNodeID,
                          const std::string& transactionID)
   {
-    return SharedHandle<DHTResponseMessage>();
+    return std::shared_ptr<DHTResponseMessage>();
   }
 
-  virtual SharedHandle<DHTQueryMessage>
-  createFindNodeMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTQueryMessage>
+  createFindNodeMessage(const std::shared_ptr<DHTNode>& remoteNode,
                         const unsigned char* targetNodeID,
                         const std::string& transactionID = "")
   {
-    return SharedHandle<DHTQueryMessage>();
+    return std::shared_ptr<DHTQueryMessage>();
   }
 
-  virtual SharedHandle<DHTResponseMessage>
+  virtual std::shared_ptr<DHTResponseMessage>
   createFindNodeReplyMessage
-  (const SharedHandle<DHTNode>& remoteNode,
-   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+  (const std::shared_ptr<DHTNode>& remoteNode,
+   const std::vector<std::shared_ptr<DHTNode> >& closestKNodes,
    const std::string& transactionID)
   {
-    return SharedHandle<DHTResponseMessage>();
+    return std::shared_ptr<DHTResponseMessage>();
   }
 
-  virtual SharedHandle<DHTQueryMessage>
-  createGetPeersMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTQueryMessage>
+  createGetPeersMessage(const std::shared_ptr<DHTNode>& remoteNode,
                         const unsigned char* infoHash,
                         const std::string& transactionID)
   {
-    return SharedHandle<DHTQueryMessage>();
+    return std::shared_ptr<DHTQueryMessage>();
   }
 
-  virtual SharedHandle<DHTResponseMessage>
+  virtual std::shared_ptr<DHTResponseMessage>
   createGetPeersReplyMessage
-  (const SharedHandle<DHTNode>& remoteNode,
-   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
-   const std::vector<SharedHandle<Peer> >& peers,
+  (const std::shared_ptr<DHTNode>& remoteNode,
+   const std::vector<std::shared_ptr<DHTNode> >& closestKNodes,
+   const std::vector<std::shared_ptr<Peer> >& peers,
    const std::string& token,
    const std::string& transactionID)
   {
-    return SharedHandle<DHTResponseMessage>();
+    return std::shared_ptr<DHTResponseMessage>();
   }
 
-  virtual SharedHandle<DHTQueryMessage>
-  createAnnouncePeerMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTQueryMessage>
+  createAnnouncePeerMessage(const std::shared_ptr<DHTNode>& remoteNode,
                             const unsigned char* infoHash,
                             uint16_t tcpPort,
                             const std::string& token,
                             const std::string& transactionID = "")
   {
-    return SharedHandle<DHTQueryMessage>();
+    return std::shared_ptr<DHTQueryMessage>();
   }
 
-  virtual SharedHandle<DHTResponseMessage>
-  createAnnouncePeerReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTResponseMessage>
+  createAnnouncePeerReplyMessage(const std::shared_ptr<DHTNode>& remoteNode,
                                  const std::string& transactionID)
   {
-    return SharedHandle<DHTResponseMessage>();
+    return std::shared_ptr<DHTResponseMessage>();
   }
 
-  virtual SharedHandle<DHTMessage>
+  virtual std::shared_ptr<DHTMessage>
   createUnknownMessage(const unsigned char* data, size_t length,
                        const std::string& ipaddr, uint16_t port)
   {
-    return SharedHandle<DHTMessage>();
+    return std::shared_ptr<DHTMessage>();
   }
 
-  void setLocalNode(const SharedHandle<DHTNode>& node)
+  void setLocalNode(const std::shared_ptr<DHTNode>& node)
   {
     localNode_ = node;
   }
diff --git a/test/MockDHTTask.h b/test/MockDHTTask.h
index bef43b83..8823a631 100644
--- a/test/MockDHTTask.h
+++ b/test/MockDHTTask.h
@@ -12,13 +12,13 @@ namespace aria2 {
 
 class MockDHTTask:public DHTTask {
 public:
-  SharedHandle<DHTNode> remoteNode_;
+  std::shared_ptr<DHTNode> remoteNode_;
 
   unsigned char targetID_[DHT_ID_LENGTH];
 
   bool finished_;
 
-  MockDHTTask(const SharedHandle<DHTNode>& remoteNode):
+  MockDHTTask(const std::shared_ptr<DHTNode>& remoteNode):
     remoteNode_(remoteNode),
     finished_(false) {}
 
diff --git a/test/MockDHTTaskFactory.h b/test/MockDHTTaskFactory.h
index 50dd1779..7b129cf8 100644
--- a/test/MockDHTTaskFactory.h
+++ b/test/MockDHTTaskFactory.h
@@ -9,43 +9,43 @@ class MockDHTTaskFactory:public DHTTaskFactory {
 public:
   virtual ~MockDHTTaskFactory() {}
 
-  virtual SharedHandle<DHTTask>
-  createPingTask(const SharedHandle<DHTNode>& remoteNode,
+  virtual std::shared_ptr<DHTTask>
+  createPingTask(const std::shared_ptr<DHTNode>& remoteNode,
                  int numRetry = 0)
   {
-    return SharedHandle<DHTTask>();
+    return std::shared_ptr<DHTTask>();
   }
 
-  virtual SharedHandle<DHTTask>
+  virtual std::shared_ptr<DHTTask>
   createNodeLookupTask(const unsigned char* targetID)
   {
-    return SharedHandle<DHTTask>();
+    return std::shared_ptr<DHTTask>();
   }
 
-  virtual SharedHandle<DHTTask> createBucketRefreshTask()
+  virtual std::shared_ptr<DHTTask> createBucketRefreshTask()
   {
-    return SharedHandle<DHTTask>();
+    return std::shared_ptr<DHTTask>();
   }
 
-  virtual SharedHandle<DHTTask>
-  createPeerLookupTask(const SharedHandle<DownloadContext>& ctx,
+  virtual std::shared_ptr<DHTTask>
+  createPeerLookupTask(const std::shared_ptr<DownloadContext>& ctx,
                        uint16_t tcpPort,
-                       const SharedHandle<PeerStorage>& peerStorage)
+                       const std::shared_ptr<PeerStorage>& peerStorage)
   {
-    return SharedHandle<DHTTask>();
+    return std::shared_ptr<DHTTask>();
   }
 
-  virtual SharedHandle<DHTTask>
+  virtual std::shared_ptr<DHTTask>
   createPeerAnnounceTask(const unsigned char* infoHash)
   {
-    return SharedHandle<DHTTask>();
+    return std::shared_ptr<DHTTask>();
   }
 
-  virtual SharedHandle<DHTTask>
-  createReplaceNodeTask(const SharedHandle<DHTBucket>& bucket,
-                        const SharedHandle<DHTNode>& newNode)
+  virtual std::shared_ptr<DHTTask>
+  createReplaceNodeTask(const std::shared_ptr<DHTBucket>& bucket,
+                        const std::shared_ptr<DHTNode>& newNode)
   {
-    return SharedHandle<DHTTask>();
+    return std::shared_ptr<DHTTask>();
   }
 };
 
diff --git a/test/MockDHTTaskQueue.h b/test/MockDHTTaskQueue.h
index 15ff687f..62ea3714 100644
--- a/test/MockDHTTaskQueue.h
+++ b/test/MockDHTTaskQueue.h
@@ -7,11 +7,11 @@ namespace aria2 {
 
 class MockDHTTaskQueue:public DHTTaskQueue {
 public:
-  std::deque<SharedHandle<DHTTask> > periodicTaskQueue1_;
+  std::deque<std::shared_ptr<DHTTask> > periodicTaskQueue1_;
 
-  std::deque<SharedHandle<DHTTask> > periodicTaskQueue2_;
+  std::deque<std::shared_ptr<DHTTask> > periodicTaskQueue2_;
 
-  std::deque<SharedHandle<DHTTask> > immediateTaskQueue_;
+  std::deque<std::shared_ptr<DHTTask> > immediateTaskQueue_;
 
   MockDHTTaskQueue() {}
 
@@ -19,17 +19,17 @@ public:
 
   virtual void executeTask() {}
 
-  virtual void addPeriodicTask1(const SharedHandle<DHTTask>& task)
+  virtual void addPeriodicTask1(const std::shared_ptr<DHTTask>& task)
   {
     periodicTaskQueue1_.push_back(task);
   }
 
-  virtual void addPeriodicTask2(const SharedHandle<DHTTask>& task)
+  virtual void addPeriodicTask2(const std::shared_ptr<DHTTask>& task)
   {
     periodicTaskQueue2_.push_back(task);
   }
 
-  virtual void addImmediateTask(const SharedHandle<DHTTask>& task)
+  virtual void addImmediateTask(const std::shared_ptr<DHTTask>& task)
   {
     immediateTaskQueue_.push_back(task);
   }
diff --git a/test/MockExtensionMessageFactory.h b/test/MockExtensionMessageFactory.h
index 80e02303..3fb422f4 100644
--- a/test/MockExtensionMessageFactory.h
+++ b/test/MockExtensionMessageFactory.h
@@ -10,10 +10,10 @@ class MockExtensionMessageFactory:public ExtensionMessageFactory {
 public:
   virtual ~MockExtensionMessageFactory() {}
 
-  virtual SharedHandle<ExtensionMessage> createMessage(const unsigned char* data,
+  virtual std::shared_ptr<ExtensionMessage> createMessage(const unsigned char* data,
                                                        size_t length)
   {
-    return SharedHandle<ExtensionMessage>
+    return std::shared_ptr<ExtensionMessage>
       (new MockExtensionMessage("a2_mock", *data, data+1, length-1));
   }
 };
diff --git a/test/MockPeerStorage.h b/test/MockPeerStorage.h
index d23dea0b..7a28c329 100644
--- a/test/MockPeerStorage.h
+++ b/test/MockPeerStorage.h
@@ -11,26 +11,26 @@ namespace aria2 {
 
 class MockPeerStorage : public PeerStorage {
 private:
-  std::deque<SharedHandle<Peer> > unusedPeers;
+  std::deque<std::shared_ptr<Peer> > unusedPeers;
   PeerSet usedPeers;
-  std::deque<SharedHandle<Peer> > droppedPeers;
-  std::vector<SharedHandle<Peer> > activePeers;
+  std::deque<std::shared_ptr<Peer> > droppedPeers;
+  std::vector<std::shared_ptr<Peer> > activePeers;
   int numChokeExecuted_;
 public:
   MockPeerStorage():numChokeExecuted_(0) {}
   virtual ~MockPeerStorage() {}
 
-  virtual bool addPeer(const SharedHandle<Peer>& peer)
+  virtual bool addPeer(const std::shared_ptr<Peer>& peer)
   {
     unusedPeers.push_back(peer);
     return true;
   }
 
-  virtual void addPeer(const std::vector<SharedHandle<Peer> >& peers) {
+  virtual void addPeer(const std::vector<std::shared_ptr<Peer> >& peers) {
     unusedPeers.insert(unusedPeers.end(), peers.begin(), peers.end());
   }
 
-  const std::deque<SharedHandle<Peer> >& getUnusedPeers()
+  const std::deque<std::shared_ptr<Peer> >& getUnusedPeers()
   {
     return unusedPeers;
   }
@@ -40,11 +40,11 @@ public:
     return unusedPeers.size() + usedPeers.size();
   }
 
-  virtual const std::deque<SharedHandle<Peer> >& getDroppedPeers() {
+  virtual const std::deque<std::shared_ptr<Peer> >& getDroppedPeers() {
     return droppedPeers;
   }
 
-  void addDroppedPeer(const SharedHandle<Peer>& peer) {
+  void addDroppedPeer(const std::shared_ptr<Peer>& peer) {
     droppedPeers.push_back(peer);
   }
 
@@ -52,12 +52,12 @@ public:
     return false;
   }
 
-  void setActivePeers(const std::vector<SharedHandle<Peer> >& activePeers)
+  void setActivePeers(const std::vector<std::shared_ptr<Peer> >& activePeers)
   {
     this->activePeers = activePeers;
   }
 
-  void getActivePeers(std::vector<SharedHandle<Peer> >& peers) {
+  void getActivePeers(std::vector<std::shared_ptr<Peer> >& peers) {
     peers.insert(peers.end(), activePeers.begin(), activePeers.end());
   }
 
@@ -75,12 +75,12 @@ public:
   {
   }
 
-  virtual SharedHandle<Peer> checkoutPeer(cuid_t cuid)
+  virtual std::shared_ptr<Peer> checkoutPeer(cuid_t cuid)
   {
-    return SharedHandle<Peer>();
+    return std::shared_ptr<Peer>();
   }
 
-  virtual void returnPeer(const SharedHandle<Peer>& peer)
+  virtual void returnPeer(const std::shared_ptr<Peer>& peer)
   {
   }
 
diff --git a/test/MockPieceStorage.h b/test/MockPieceStorage.h
index 16f480ad..dc39594b 100644
--- a/test/MockPieceStorage.h
+++ b/test/MockPieceStorage.h
@@ -20,9 +20,9 @@ private:
   BitfieldMan* bitfieldMan;
   bool selectiveDownloadingMode;
   bool endGame;
-  SharedHandle<DiskAdaptor> diskAdaptor;
+  std::shared_ptr<DiskAdaptor> diskAdaptor;
   std::deque<int32_t> pieceLengthList;
-  std::deque<SharedHandle<Piece> > inFlightPieces;
+  std::deque<std::shared_ptr<Piece> > inFlightPieces;
   bool downloadFinished_;
   bool allDownloadFinished_;
 public:
@@ -40,53 +40,53 @@ public:
 
 #ifdef ENABLE_BITTORRENT
 
-  virtual bool hasMissingPiece(const SharedHandle<Peer>& peer) {
+  virtual bool hasMissingPiece(const std::shared_ptr<Peer>& peer) {
     return false;
   }
 
   virtual void getMissingPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    cuid_t cuid)
   {}
 
   virtual void getMissingPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
    cuid_t cuid)
   {}
 
   virtual void getMissingFastPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    cuid_t cuid)
   {}
 
   virtual void getMissingFastPiece
-  (std::vector<SharedHandle<Piece> >& pieces,
+  (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
-   const SharedHandle<Peer>& peer,
+   const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
    cuid_t cuid)
   {}
 
-  virtual SharedHandle<Piece> getMissingPiece
-  (const SharedHandle<Peer>& peer,
+  virtual std::shared_ptr<Piece> getMissingPiece
+  (const std::shared_ptr<Peer>& peer,
    cuid_t cuid)
   {
-    return SharedHandle<Piece>(new Piece());
+    return std::shared_ptr<Piece>(new Piece());
   }
 
-  virtual SharedHandle<Piece> getMissingPiece
-  (const SharedHandle<Peer>& peer,
+  virtual std::shared_ptr<Piece> getMissingPiece
+  (const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
    cuid_t cuid)
   {
-    return SharedHandle<Piece>(new Piece());
+    return std::shared_ptr<Piece>(new Piece());
   }
 
 #endif // ENABLE_BITTORRENT
@@ -96,18 +96,18 @@ public:
     return false;
   }
 
-  virtual SharedHandle<Piece> getMissingPiece
+  virtual std::shared_ptr<Piece> getMissingPiece
   (size_t minSplitSize,
    const unsigned char* ignoreBitfield,
    size_t length,
    cuid_t cuid)
   {
-    return SharedHandle<Piece>(new Piece());
+    return std::shared_ptr<Piece>(new Piece());
   }
 
-  virtual SharedHandle<Piece> getMissingPiece(size_t index, cuid_t cuid)
+  virtual std::shared_ptr<Piece> getMissingPiece(size_t index, cuid_t cuid)
   {
-    return SharedHandle<Piece>(new Piece());
+    return std::shared_ptr<Piece>(new Piece());
   }
 
   virtual bool isPieceUsed(size_t index)
@@ -119,13 +119,13 @@ public:
 
   virtual void markPiecesDone(int64_t) {}
 
-  virtual SharedHandle<Piece> getPiece(size_t index) {
-    return SharedHandle<Piece>(new Piece());
+  virtual std::shared_ptr<Piece> getPiece(size_t index) {
+    return std::shared_ptr<Piece>(new Piece());
   }
 
-  virtual void completePiece(const SharedHandle<Piece>& piece) {}
+  virtual void completePiece(const std::shared_ptr<Piece>& piece) {}
 
-  virtual void cancelPiece(const SharedHandle<Piece>& piece, cuid_t cuid) {}
+  virtual void cancelPiece(const std::shared_ptr<Piece>& piece, cuid_t cuid) {}
 
   virtual bool hasPiece(size_t index) {
     return false;
@@ -222,7 +222,7 @@ public:
     this->endGame = true;
   }
 
-  virtual SharedHandle<DiskAdaptor> getDiskAdaptor() {
+  virtual std::shared_ptr<DiskAdaptor> getDiskAdaptor() {
     return diskAdaptor;
   }
 
@@ -232,7 +232,7 @@ public:
 
   virtual void flushWrDiskCacheEntry() {}
 
-  void setDiskAdaptor(const SharedHandle<DiskAdaptor>& adaptor) {
+  void setDiskAdaptor(const std::shared_ptr<DiskAdaptor>& adaptor) {
     this->diskAdaptor = adaptor;
   }
 
@@ -255,7 +255,7 @@ public:
 
   virtual void markAllPiecesDone() {}
 
-  virtual void addInFlightPiece(const std::vector<SharedHandle<Piece> >& pieces)
+  virtual void addInFlightPiece(const std::vector<std::shared_ptr<Piece> >& pieces)
   {
     std::copy(pieces.begin(), pieces.end(), back_inserter(inFlightPieces));
   }
@@ -265,7 +265,7 @@ public:
     return inFlightPieces.size();
   }
 
-  virtual void getInFlightPieces(std::vector<SharedHandle<Piece> >& pieces)
+  virtual void getInFlightPieces(std::vector<std::shared_ptr<Piece> >& pieces)
   {
     pieces.insert(pieces.end(), inFlightPieces.begin(), inFlightPieces.end());
   }
diff --git a/test/MockSegment.h b/test/MockSegment.h
index 42e29de1..4cdebbdf 100644
--- a/test/MockSegment.h
+++ b/test/MockSegment.h
@@ -69,9 +69,9 @@ public:
 
   virtual void clear(WrDiskCache* diskCache) {}
 
-  virtual SharedHandle<Piece> getPiece() const
+  virtual std::shared_ptr<Piece> getPiece() const
   {
-    return SharedHandle<Piece>(new Piece());
+    return std::shared_ptr<Piece>(new Piece());
   }
 };
 
diff --git a/test/MultiDiskAdaptorTest.cc b/test/MultiDiskAdaptorTest.cc
index dac76832..8d66130c 100644
--- a/test/MultiDiskAdaptorTest.cc
+++ b/test/MultiDiskAdaptorTest.cc
@@ -28,7 +28,7 @@ class MultiDiskAdaptorTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testWriteCache);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<MultiDiskAdaptor> adaptor;
+  std::shared_ptr<MultiDiskAdaptor> adaptor;
 public:
   void setUp() {
     adaptor.reset(new MultiDiskAdaptor());
@@ -47,17 +47,17 @@ public:
 
 CPPUNIT_TEST_SUITE_REGISTRATION( MultiDiskAdaptorTest );
 
-std::vector<SharedHandle<FileEntry> > createEntries() {
-  SharedHandle<FileEntry> array[] = {
-    SharedHandle<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file0.txt", 0, 0)),
-    SharedHandle<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file1.txt", 15, 0)),
-    SharedHandle<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file2.txt", 7, 15)),
-    SharedHandle<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file3.txt", 0, 22)),
-    SharedHandle<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file4.txt", 2, 22)),
-    SharedHandle<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file5.txt", 0, 24)),
-    SharedHandle<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file6.txt", 3, 24)),
-    SharedHandle<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file7.txt", 0, 27)),
-    SharedHandle<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file8.txt", 2, 27)),
+std::vector<std::shared_ptr<FileEntry> > createEntries() {
+  std::shared_ptr<FileEntry> array[] = {
+    std::shared_ptr<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file0.txt", 0, 0)),
+    std::shared_ptr<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file1.txt", 15, 0)),
+    std::shared_ptr<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file2.txt", 7, 15)),
+    std::shared_ptr<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file3.txt", 0, 22)),
+    std::shared_ptr<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file4.txt", 2, 22)),
+    std::shared_ptr<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file5.txt", 0, 24)),
+    std::shared_ptr<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file6.txt", 3, 24)),
+    std::shared_ptr<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file7.txt", 0, 27)),
+    std::shared_ptr<FileEntry>(new FileEntry(A2_TEST_OUT_DIR"/file8.txt", 2, 27)),
   };
   //           1    1    2    2    3
   // 0....5....0....5....0....5....0
@@ -71,8 +71,8 @@ std::vector<SharedHandle<FileEntry> > createEntries() {
   //                         *** file6
   //                            |file7
   //                            ** file8
-  std::vector<SharedHandle<FileEntry> > entries(vbegin(array), vend(array));
-  for(std::vector<SharedHandle<FileEntry> >::const_iterator i = entries.begin();
+  std::vector<std::shared_ptr<FileEntry> > entries(vbegin(array), vend(array));
+  for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i = entries.begin();
       i != entries.end(); ++i) {
     File((*i)->getPath()).remove();
   }
@@ -82,12 +82,12 @@ std::vector<SharedHandle<FileEntry> > createEntries() {
 void MultiDiskAdaptorTest::testResetDiskWriterEntries()
 {
   {
-    std::vector<SharedHandle<FileEntry> > fileEntries = createEntries();
+    std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries();
     adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
     // In openFile(), resetDiskWriterEntries() are called.
     adaptor->openFile();
 
-    std::vector<SharedHandle<DiskWriterEntry> > entries =
+    std::vector<std::shared_ptr<DiskWriterEntry> > entries =
       adaptor->getDiskWriterEntries();
     CPPUNIT_ASSERT(entries[0]->getDiskWriter());
     CPPUNIT_ASSERT(entries[1]->getDiskWriter());
@@ -99,13 +99,13 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
     adaptor->closeFile();
   }
   {
-    std::vector<SharedHandle<FileEntry> > fileEntries = createEntries();
+    std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries();
     fileEntries[0]->setRequested(false);
     adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
     // In openFile(), resetDiskWriterEntries() are called.
     adaptor->openFile();
 
-    std::vector<SharedHandle<DiskWriterEntry> > entries =
+    std::vector<std::shared_ptr<DiskWriterEntry> > entries =
       adaptor->getDiskWriterEntries();
     // Because entries[1] spans entries[0]
     CPPUNIT_ASSERT(entries[0]->getDiskWriter());
@@ -118,14 +118,14 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
     adaptor->closeFile();
   }
   {
-    std::vector<SharedHandle<FileEntry> > fileEntries = createEntries();
+    std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries();
     fileEntries[0]->setRequested(false);
     fileEntries[1]->setRequested(false);
     adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
     // In openFile(), resetDiskWriterEntries() are called.
     adaptor->openFile();
 
-    std::vector<SharedHandle<DiskWriterEntry> > entries =
+    std::vector<std::shared_ptr<DiskWriterEntry> > entries =
       adaptor->getDiskWriterEntries();
     CPPUNIT_ASSERT(!entries[0]->getDiskWriter());
     // Because entries[2] spans entries[1]
@@ -139,13 +139,13 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
     adaptor->closeFile();
   }
   {
-    std::vector<SharedHandle<FileEntry> > fileEntries = createEntries();
+    std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries();
     fileEntries[3]->setRequested(false);
     adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
     // In openFile(), resetDiskWriterEntries() are called.
     adaptor->openFile();
 
-    std::vector<SharedHandle<DiskWriterEntry> > entries =
+    std::vector<std::shared_ptr<DiskWriterEntry> > entries =
       adaptor->getDiskWriterEntries();
     CPPUNIT_ASSERT(entries[0]->getDiskWriter());
     CPPUNIT_ASSERT(entries[1]->getDiskWriter());
@@ -159,13 +159,13 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
     adaptor->closeFile();
   }
   {
-    std::vector<SharedHandle<FileEntry> > fileEntries = createEntries();
+    std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries();
     fileEntries[4]->setRequested(false);
     adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
     // In openFile(), resetDiskWriterEntries() are called.
     adaptor->openFile();
 
-    std::vector<SharedHandle<DiskWriterEntry> > entries =
+    std::vector<std::shared_ptr<DiskWriterEntry> > entries =
       adaptor->getDiskWriterEntries();
     CPPUNIT_ASSERT(entries[0]->getDiskWriter());
     CPPUNIT_ASSERT(entries[1]->getDiskWriter());
@@ -178,14 +178,14 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
     adaptor->closeFile();
   }
   {
-    std::vector<SharedHandle<FileEntry> > fileEntries = createEntries();
+    std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries();
     fileEntries[3]->setRequested(false);
     fileEntries[4]->setRequested(false);
     adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
     // In openFile(), resetDiskWriterEntries() are called.
     adaptor->openFile();
 
-    std::vector<SharedHandle<DiskWriterEntry> > entries =
+    std::vector<std::shared_ptr<DiskWriterEntry> > entries =
       adaptor->getDiskWriterEntries();
     CPPUNIT_ASSERT(entries[0]->getDiskWriter());
     CPPUNIT_ASSERT(entries[1]->getDiskWriter());
@@ -197,7 +197,7 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
     adaptor->closeFile();
   }
   {
-    std::vector<SharedHandle<FileEntry> > fileEntries = createEntries();
+    std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries();
     for(size_t i = 5; i < 9; ++i) {
       fileEntries[i]->setRequested(false);
     }
@@ -205,7 +205,7 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
     // In openFile(), resetDiskWriterEntries() are called.
     adaptor->openFile();
 
-    std::vector<SharedHandle<DiskWriterEntry> > entries =
+    std::vector<std::shared_ptr<DiskWriterEntry> > entries =
       adaptor->getDiskWriterEntries();
     CPPUNIT_ASSERT(entries[0]->getDiskWriter());
     CPPUNIT_ASSERT(entries[1]->getDiskWriter());
@@ -217,13 +217,13 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
     adaptor->closeFile();
   }
   {
-    std::vector<SharedHandle<FileEntry> > fileEntries = createEntries();
+    std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries();
     for(size_t i = 1; i < 9; ++i) {
       fileEntries[i]->setRequested(false);
     }
     adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
     adaptor->openFile();
-    std::vector<SharedHandle<DiskWriterEntry> > entries =
+    std::vector<std::shared_ptr<DiskWriterEntry> > entries =
       adaptor->getDiskWriterEntries();
     CPPUNIT_ASSERT(entries[0]->getDiskWriter());
     CPPUNIT_ASSERT(!entries[1]->getDiskWriter());
@@ -235,13 +235,13 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
     adaptor->closeFile();
   }
   {
-    std::vector<SharedHandle<FileEntry> > fileEntries = createEntries();
+    std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries();
     for(size_t i = 2; i < 9; ++i) {
       fileEntries[i]->setRequested(false);
     }
     adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
     adaptor->openFile();
-    std::vector<SharedHandle<DiskWriterEntry> > entries =
+    std::vector<std::shared_ptr<DiskWriterEntry> > entries =
       adaptor->getDiskWriterEntries();
     CPPUNIT_ASSERT(entries[0]->getDiskWriter());
     CPPUNIT_ASSERT(entries[1]->getDiskWriter());
@@ -255,14 +255,14 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
     adaptor->closeFile();
   }
   {
-    std::vector<SharedHandle<FileEntry> > fileEntries = createEntries();
+    std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries();
     for(size_t i = 0; i < 6; ++i) {
       fileEntries[i]->setRequested(false);
     }
     fileEntries[8]->setRequested(false);
     adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
     adaptor->openFile();
-    std::vector<SharedHandle<DiskWriterEntry> > entries =
+    std::vector<std::shared_ptr<DiskWriterEntry> > entries =
       adaptor->getDiskWriterEntries();
     CPPUNIT_ASSERT(!entries[0]->getDiskWriter());
     CPPUNIT_ASSERT(!entries[1]->getDiskWriter());
@@ -292,7 +292,7 @@ void readFile(const std::string& filename, char* buf, int bufLength) {
 }
 
 void MultiDiskAdaptorTest::testWriteData() {
-  std::vector<SharedHandle<FileEntry> > fileEntries(createEntries());
+  std::vector<std::shared_ptr<FileEntry> > fileEntries(createEntries());
   adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
 
   adaptor->openFile();
@@ -340,10 +340,10 @@ void MultiDiskAdaptorTest::testWriteData() {
 }
 
 void MultiDiskAdaptorTest::testReadData() {
-  SharedHandle<FileEntry> entry1(new FileEntry(A2_TEST_DIR"/file1r.txt", 15, 0));
-  SharedHandle<FileEntry> entry2(new FileEntry(A2_TEST_DIR"/file2r.txt", 7, 15));
-  SharedHandle<FileEntry> entry3(new FileEntry(A2_TEST_DIR"/file3r.txt", 3, 22));
-  std::vector<SharedHandle<FileEntry> > entries;
+  std::shared_ptr<FileEntry> entry1(new FileEntry(A2_TEST_DIR"/file1r.txt", 15, 0));
+  std::shared_ptr<FileEntry> entry2(new FileEntry(A2_TEST_DIR"/file2r.txt", 7, 15));
+  std::shared_ptr<FileEntry> entry3(new FileEntry(A2_TEST_DIR"/file3r.txt", 3, 22));
+  std::vector<std::shared_ptr<FileEntry> > entries;
   entries.push_back(entry1);
   entries.push_back(entry2);
   entries.push_back(entry3);
@@ -370,14 +370,14 @@ void MultiDiskAdaptorTest::testCutTrailingGarbage()
 {
   std::string dir = A2_TEST_OUT_DIR;
   std::string prefix = "aria2_MultiDiskAdaptorTest_testCutTrailingGarbage_";
-  SharedHandle<FileEntry> entries[] = {
-    SharedHandle<FileEntry>(new FileEntry(dir+"/"+prefix+"1", 256, 0)),
-    SharedHandle<FileEntry>(new FileEntry(dir+"/"+prefix+"2", 512, 256))
+  std::shared_ptr<FileEntry> entries[] = {
+    std::shared_ptr<FileEntry>(new FileEntry(dir+"/"+prefix+"1", 256, 0)),
+    std::shared_ptr<FileEntry>(new FileEntry(dir+"/"+prefix+"2", 512, 256))
   };
   for(size_t i = 0; i < A2_ARRAY_LEN(entries); ++i) {
     createFile(entries[i]->getPath(), entries[i]->getLength()+100);
   }
-  std::vector<SharedHandle<FileEntry> > fileEntries
+  std::vector<std::shared_ptr<FileEntry> > fileEntries
     (vbegin(entries), vend(entries));
 
   MultiDiskAdaptor adaptor;
@@ -399,14 +399,14 @@ void MultiDiskAdaptorTest::testSize()
 {
   std::string dir = A2_TEST_OUT_DIR;
   std::string prefix = "aria2_MultiDiskAdaptorTest_testSize_";
-  SharedHandle<FileEntry> entries[] = {
-    SharedHandle<FileEntry>(new FileEntry(dir+"/"+prefix+"1", 1, 0)),
-    SharedHandle<FileEntry>(new FileEntry(dir+"/"+prefix+"2", 1, 1))
+  std::shared_ptr<FileEntry> entries[] = {
+    std::shared_ptr<FileEntry>(new FileEntry(dir+"/"+prefix+"1", 1, 0)),
+    std::shared_ptr<FileEntry>(new FileEntry(dir+"/"+prefix+"2", 1, 1))
   };
   for(size_t i = 0; i < A2_ARRAY_LEN(entries); ++i) {
     createFile(entries[i]->getPath(), entries[i]->getLength());
   }
-  std::vector<SharedHandle<FileEntry> > fileEntries
+  std::vector<std::shared_ptr<FileEntry> > fileEntries
     (vbegin(entries), vend(entries));
 
   MultiDiskAdaptor adaptor;
@@ -422,11 +422,11 @@ void MultiDiskAdaptorTest::testSize()
 void MultiDiskAdaptorTest::testUtime()
 {
   std::string storeDir = A2_TEST_OUT_DIR"/aria2_MultiDiskAdaptorTest_testUtime";
-  SharedHandle<FileEntry> entries[] = {
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/requested", 0, 0)),
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/notFound", 0, 0)),
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/notRequested", 0, 0)),
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/anotherRequested", 0, 0)),
+  std::shared_ptr<FileEntry> entries[] = {
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/requested", 0, 0)),
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/notFound", 0, 0)),
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/notRequested", 0, 0)),
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/anotherRequested", 0, 0)),
   };
 
   createFile(entries[0]->getPath(), entries[0]->getLength());
@@ -436,7 +436,7 @@ void MultiDiskAdaptorTest::testUtime()
 
   entries[2]->setRequested(false);
 
-  std::vector<SharedHandle<FileEntry> > fileEntries
+  std::vector<std::shared_ptr<FileEntry> > fileEntries
     (vbegin(entries), vend(entries));
   MultiDiskAdaptor adaptor;
   adaptor.setFileEntries(fileEntries.begin(), fileEntries.end());
@@ -460,14 +460,14 @@ void MultiDiskAdaptorTest::testWriteCache()
 {
   std::string storeDir =
     A2_TEST_OUT_DIR"/aria2_MultiDiskAdaptorTest_testWriteCache";
-  SharedHandle<FileEntry> entries[] = {
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/file1", 16385, 0)),
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/file2", 4098, 16385))
+  std::shared_ptr<FileEntry> entries[] = {
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file1", 16385, 0)),
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file2", 4098, 16385))
   };
   for(int i = 0; i < 2; ++i) {
     File(entries[i]->getPath()).remove();
   }
-  SharedHandle<MultiDiskAdaptor> adaptor(new MultiDiskAdaptor());
+  std::shared_ptr<MultiDiskAdaptor> adaptor(new MultiDiskAdaptor());
   adaptor->setFileEntries(vbegin(entries), vend(entries));
   WrDiskCacheEntry cache(adaptor);
   std::string data1(16383, '1'), data2(100, '2'), data3(4000, '3');
diff --git a/test/MultiFileAllocationIteratorTest.cc b/test/MultiFileAllocationIteratorTest.cc
index d85eff57..498f347d 100644
--- a/test/MultiFileAllocationIteratorTest.cc
+++ b/test/MultiFileAllocationIteratorTest.cc
@@ -38,18 +38,18 @@ void MultiFileAllocationIteratorTest::testMakeDiskWriterEntries()
   std::string storeDir = A2_TEST_OUT_DIR"/aria2_MultiFileAllocationIteratorTest"
     "_testMakeDiskWriterEntries";
 
-  SharedHandle<FileEntry> fs[] = {
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/file1", 1536, 0)),
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/file2", 2048, 1536)),// req no
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/file3", 1024, 3584)),
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/file4", 1024, 4608)),// req no
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/file5", 1024, 5632)),// req no
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/file6", 1024, 6656)),// req no
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/file7",  256, 7680)),// req no
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/file8",  255, 7936)),
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/file9", 1025, 8191)),// req no
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/fileA", 1024, 9216)),// req no
-    SharedHandle<FileEntry>(new FileEntry(storeDir+"/fileB", 1024, 10240)),
+  std::shared_ptr<FileEntry> fs[] = {
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file1", 1536, 0)),
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file2", 2048, 1536)),// req no
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file3", 1024, 3584)),
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file4", 1024, 4608)),// req no
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file5", 1024, 5632)),// req no
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file6", 1024, 6656)),// req no
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file7",  256, 7680)),// req no
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file8",  255, 7936)),
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file9", 1025, 8191)),// req no
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/fileA", 1024, 9216)),// req no
+    std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/fileB", 1024, 10240)),
   };
   fs[1]->setRequested(false); // file2
   fs[3]->setRequested(false); // file4
@@ -63,16 +63,15 @@ void MultiFileAllocationIteratorTest::testMakeDiskWriterEntries()
   // create empty file4
   createFile(storeDir+std::string("/file4"), 0);
 
-  SharedHandle<MultiDiskAdaptor> diskAdaptor(new MultiDiskAdaptor());
+  std::shared_ptr<MultiDiskAdaptor> diskAdaptor(new MultiDiskAdaptor());
   diskAdaptor->setFileEntries(vbegin(fs), vend(fs));
   diskAdaptor->setPieceLength(1024);
   diskAdaptor->openFile();
 
-  SharedHandle<MultiFileAllocationIterator> itr
-    (dynamic_pointer_cast<MultiFileAllocationIterator>
-     (diskAdaptor->fileAllocationIterator()));
+  auto itr = std::dynamic_pointer_cast<MultiFileAllocationIterator>
+    (diskAdaptor->fileAllocationIterator());
 
-  const std::deque<SharedHandle<DiskWriterEntry> >& entries =
+  const std::deque<std::shared_ptr<DiskWriterEntry> >& entries =
     itr->getDiskWriterEntries();
 
   CPPUNIT_ASSERT_EQUAL((size_t)11, entries.size());
@@ -153,41 +152,41 @@ void MultiFileAllocationIteratorTest::testAllocate()
   int64_t length6 = 30;
 
   try {
-    SharedHandle<MultiDiskAdaptor> diskAdaptor(new MultiDiskAdaptor());
+    std::shared_ptr<MultiDiskAdaptor> diskAdaptor(new MultiDiskAdaptor());
     diskAdaptor->setPieceLength(1);
 
     int64_t offset = 0;
-    SharedHandle<FileEntry> fileEntry1(new FileEntry(storeDir+"/"+fname1,
+    std::shared_ptr<FileEntry> fileEntry1(new FileEntry(storeDir+"/"+fname1,
                                                      length1,
                                                      offset));
     offset += length1;
-    SharedHandle<FileEntry> fileEntry2(new FileEntry(storeDir+"/"+fname2,
+    std::shared_ptr<FileEntry> fileEntry2(new FileEntry(storeDir+"/"+fname2,
                                                      length2,
                                                      offset));
 
     offset += length2;
-    SharedHandle<FileEntry> fileEntry3(new FileEntry(storeDir+"/"+fname3,
+    std::shared_ptr<FileEntry> fileEntry3(new FileEntry(storeDir+"/"+fname3,
                                                      length3,
                                                      offset));
 
     offset += length3;
-    SharedHandle<FileEntry> fileEntry4(new FileEntry(storeDir+"/"+fname4,
+    std::shared_ptr<FileEntry> fileEntry4(new FileEntry(storeDir+"/"+fname4,
                                                      length4,
                                                      offset));
     fileEntry4->setRequested(false);
 
     offset += length4;
-    SharedHandle<FileEntry> fileEntry5(new FileEntry(storeDir+"/"+fname5,
+    std::shared_ptr<FileEntry> fileEntry5(new FileEntry(storeDir+"/"+fname5,
                                                      length5,
                                                      offset));
 
     offset += length5;
-    SharedHandle<FileEntry> fileEntry6(new FileEntry(storeDir+"/"+fname6,
+    std::shared_ptr<FileEntry> fileEntry6(new FileEntry(storeDir+"/"+fname6,
                                                      length6,
                                                      offset));
     fileEntry6->setRequested(false);
 
-    std::vector<SharedHandle<FileEntry> > fs;
+    std::vector<std::shared_ptr<FileEntry> > fs;
     fs.push_back(fileEntry1);
     fs.push_back(fileEntry2);
     fs.push_back(fileEntry3);
@@ -196,16 +195,15 @@ void MultiFileAllocationIteratorTest::testAllocate()
     fs.push_back(fileEntry6);
     diskAdaptor->setFileEntries(fs.begin(), fs.end());
 
-    for(std::vector<SharedHandle<FileEntry> >::const_iterator i = fs.begin();
+    for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i = fs.begin();
         i != fs.end(); ++i) {
       File((*i)->getPath()).remove();
     }
 
     // we have to open file first.
     diskAdaptor->initAndOpenFile();
-    SharedHandle<MultiFileAllocationIterator> itr
-      (dynamic_pointer_cast<MultiFileAllocationIterator>
-       (diskAdaptor->fileAllocationIterator()));
+    auto itr = std::dynamic_pointer_cast<MultiFileAllocationIterator>
+      (diskAdaptor->fileAllocationIterator());
     while(!itr->finished()) {
       itr->allocateChunk();
     }
diff --git a/test/NetrcAuthResolverTest.cc b/test/NetrcAuthResolverTest.cc
index 4f97fbaa..0a455b32 100644
--- a/test/NetrcAuthResolverTest.cc
+++ b/test/NetrcAuthResolverTest.cc
@@ -14,23 +14,23 @@ class NetrcAuthResolverTest : public CppUnit::TestFixture {
   CPPUNIT_TEST(testResolveAuthConfig_ignoreDefault);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<Netrc> netrc_;
-  //SharedHandle<Option> _option;
-  SharedHandle<NetrcAuthResolver> resolver_;
+  std::shared_ptr<Netrc> netrc_;
+  //std::shared_ptr<Option> _option;
+  std::shared_ptr<NetrcAuthResolver> resolver_;
 public:
   void setUp()
   {
     netrc_.reset(new Netrc());
     netrc_->addAuthenticator
-      (SharedHandle<Authenticator>(new Authenticator("localhost", "name", "passwd", "account")));
+      (std::shared_ptr<Authenticator>(new Authenticator("localhost", "name", "passwd", "account")));
     netrc_->addAuthenticator
-      (SharedHandle<Authenticator>(new DefaultAuthenticator("default", "defaultpasswd", "defaultaccount")));
+      (std::shared_ptr<Authenticator>(new DefaultAuthenticator("default", "defaultpasswd", "defaultaccount")));
 
     //_option = new Option();
     resolver_.reset(new NetrcAuthResolver());
     resolver_->setNetrc(netrc_);
     resolver_->setDefaultAuthConfig
-      (SharedHandle<AuthConfig>(new AuthConfig("foo", "bar")));
+      (std::shared_ptr<AuthConfig>(new AuthConfig("foo", "bar")));
   }
 
   void testResolveAuthConfig_without_userDefined();
@@ -43,13 +43,13 @@ CPPUNIT_TEST_SUITE_REGISTRATION( NetrcAuthResolverTest );
 
 void NetrcAuthResolverTest::testResolveAuthConfig_without_userDefined()
 {
-  SharedHandle<AuthConfig> authConfig = resolver_->resolveAuthConfig("localhost");
+  std::shared_ptr<AuthConfig> authConfig = resolver_->resolveAuthConfig("localhost");
   CPPUNIT_ASSERT_EQUAL(std::string("name:passwd"), authConfig->getAuthText());
 
   authConfig = resolver_->resolveAuthConfig("mymachine");
   CPPUNIT_ASSERT_EQUAL(std::string("default:defaultpasswd"), authConfig->getAuthText());
 
-  resolver_->setNetrc(SharedHandle<Netrc>());
+  resolver_->setNetrc(std::shared_ptr<Netrc>());
   authConfig = resolver_->resolveAuthConfig("localhost");
   CPPUNIT_ASSERT_EQUAL(std::string("foo:bar"), authConfig->getAuthText());
 
@@ -58,14 +58,14 @@ void NetrcAuthResolverTest::testResolveAuthConfig_without_userDefined()
 void NetrcAuthResolverTest::testResolveAuthConfig_with_userDefined()
 {
   resolver_->setUserDefinedAuthConfig
-    (SharedHandle<AuthConfig>(new AuthConfig("myname", "mypasswd")));
-  SharedHandle<AuthConfig> authConfig = resolver_->resolveAuthConfig("localhost");
+    (std::shared_ptr<AuthConfig>(new AuthConfig("myname", "mypasswd")));
+  std::shared_ptr<AuthConfig> authConfig = resolver_->resolveAuthConfig("localhost");
   CPPUNIT_ASSERT_EQUAL(std::string("myname:mypasswd"), authConfig->getAuthText());
 
   authConfig = resolver_->resolveAuthConfig("mymachine");
   CPPUNIT_ASSERT_EQUAL(std::string("myname:mypasswd"), authConfig->getAuthText());
 
-  resolver_->setNetrc(SharedHandle<Netrc>());
+  resolver_->setNetrc(std::shared_ptr<Netrc>());
   authConfig = resolver_->resolveAuthConfig("mymachine");
   CPPUNIT_ASSERT_EQUAL(std::string("myname:mypasswd"), authConfig->getAuthText());
 }
@@ -73,11 +73,11 @@ void NetrcAuthResolverTest::testResolveAuthConfig_with_userDefined()
 void NetrcAuthResolverTest::testResolveAuthConfig_ignoreDefault()
 {
   resolver_->ignoreDefault();
-  SharedHandle<AuthConfig> authConfig = resolver_->resolveAuthConfig("mirror");
+  std::shared_ptr<AuthConfig> authConfig = resolver_->resolveAuthConfig("mirror");
   CPPUNIT_ASSERT_EQUAL(std::string("foo:bar"), authConfig->getAuthText());
 
   resolver_->useDefault();
-  SharedHandle<AuthConfig> defAuthConfig =
+  std::shared_ptr<AuthConfig> defAuthConfig =
     resolver_->resolveAuthConfig("mirror");
   CPPUNIT_ASSERT_EQUAL(std::string("default:defaultpasswd"),
                        defAuthConfig->getAuthText());
diff --git a/test/NetrcTest.cc b/test/NetrcTest.cc
index a47c046a..90e27af2 100644
--- a/test/NetrcTest.cc
+++ b/test/NetrcTest.cc
@@ -36,32 +36,32 @@ void NetrcTest::testFindAuthenticator()
 {
   Netrc netrc;
   netrc.addAuthenticator
-    (SharedHandle<Authenticator>(new Authenticator("host1", "tujikawa", "tujikawapasswd", "tujikawaaccount")));
+    (std::shared_ptr<Authenticator>(new Authenticator("host1", "tujikawa", "tujikawapasswd", "tujikawaaccount")));
   netrc.addAuthenticator
-    (SharedHandle<Authenticator>(new Authenticator("host2", "aria2", "aria2password", "aria2account")));
+    (std::shared_ptr<Authenticator>(new Authenticator("host2", "aria2", "aria2password", "aria2account")));
   netrc.addAuthenticator
-    (SharedHandle<Authenticator>(new Authenticator(".my.domain", "dmname", "dmpass", "dmaccount")));
+    (std::shared_ptr<Authenticator>(new Authenticator(".my.domain", "dmname", "dmpass", "dmaccount")));
   netrc.addAuthenticator
-    (SharedHandle<Authenticator>(new DefaultAuthenticator("default", "defaultpassword", "defaultaccount")));
+    (std::shared_ptr<Authenticator>(new DefaultAuthenticator("default", "defaultpassword", "defaultaccount")));
 
-  SharedHandle<Authenticator> aria2auth = netrc.findAuthenticator("host2");
+  std::shared_ptr<Authenticator> aria2auth = netrc.findAuthenticator("host2");
   CPPUNIT_ASSERT(aria2auth);
   CPPUNIT_ASSERT_EQUAL(std::string("aria2"), aria2auth->getLogin());
   CPPUNIT_ASSERT_EQUAL(std::string("aria2password"), aria2auth->getPassword());
   CPPUNIT_ASSERT_EQUAL(std::string("aria2account"), aria2auth->getAccount());
 
-  SharedHandle<Authenticator> defaultauth = netrc.findAuthenticator("host3");
+  std::shared_ptr<Authenticator> defaultauth = netrc.findAuthenticator("host3");
   CPPUNIT_ASSERT(defaultauth);
   CPPUNIT_ASSERT_EQUAL(std::string("default"), defaultauth->getLogin());
   CPPUNIT_ASSERT_EQUAL(std::string("defaultpassword"), defaultauth->getPassword());
   CPPUNIT_ASSERT_EQUAL(std::string("defaultaccount"), defaultauth->getAccount());
 
-  SharedHandle<Authenticator> domainMatchAuth =
+  std::shared_ptr<Authenticator> domainMatchAuth =
     netrc.findAuthenticator("host3.my.domain");
   CPPUNIT_ASSERT(domainMatchAuth);
   CPPUNIT_ASSERT_EQUAL(std::string("dmname"), domainMatchAuth->getLogin());
 
-  SharedHandle<Authenticator> domainMatchAuth2 =
+  std::shared_ptr<Authenticator> domainMatchAuth2 =
     netrc.findAuthenticator("my.domain");
   CPPUNIT_ASSERT(domainMatchAuth2);
   CPPUNIT_ASSERT_EQUAL(std::string("default"), domainMatchAuth2->getLogin());
@@ -71,24 +71,24 @@ void NetrcTest::testParse()
 {
   Netrc netrc;
   netrc.parse(A2_TEST_DIR"/sample.netrc");
-  std::vector<SharedHandle<Authenticator> >::const_iterator itr =
+  std::vector<std::shared_ptr<Authenticator> >::const_iterator itr =
     netrc.getAuthenticators().begin();
 
-  SharedHandle<Authenticator> tujikawaauth = *itr;
+  std::shared_ptr<Authenticator> tujikawaauth = *itr;
   CPPUNIT_ASSERT(tujikawaauth);
   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;
-  SharedHandle<Authenticator> aria2auth = *itr;
+  std::shared_ptr<Authenticator> aria2auth = *itr;
   CPPUNIT_ASSERT(aria2auth);
   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;
-  SharedHandle<Authenticator> defaultauth = *itr;
+  std::shared_ptr<Authenticator> defaultauth = *itr;
   CPPUNIT_ASSERT(defaultauth);
   CPPUNIT_ASSERT_EQUAL(std::string("anonymous"), defaultauth->getLogin());
   CPPUNIT_ASSERT_EQUAL(std::string("ARIA2@USER"), defaultauth->getPassword());
diff --git a/test/OptionParserTest.cc b/test/OptionParserTest.cc
index 31aaf93c..26d28684 100644
--- a/test/OptionParserTest.cc
+++ b/test/OptionParserTest.cc
@@ -30,7 +30,7 @@ class OptionParserTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testParseKeyVals);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<OptionParser> oparser_;
+  std::shared_ptr<OptionParser> oparser_;
 public:
   void setUp()
   {
diff --git a/test/OptionTest.cc b/test/OptionTest.cc
index f33a4a6f..f7ce58f2 100644
--- a/test/OptionTest.cc
+++ b/test/OptionTest.cc
@@ -98,7 +98,7 @@ void OptionTest::testMerge()
 void OptionTest::testParent()
 {
   Option child;
-  SharedHandle<Option> parent(new Option());
+  std::shared_ptr<Option> parent(new Option());
   parent->put(PREF_TIMEOUT, "100");
   child.put(PREF_DIR, "foo");
   CPPUNIT_ASSERT(!child.defined(PREF_TIMEOUT));
diff --git a/test/PeerConnectionTest.cc b/test/PeerConnectionTest.cc
index c2a4f5a2..6e0bf9d2 100644
--- a/test/PeerConnectionTest.cc
+++ b/test/PeerConnectionTest.cc
@@ -21,7 +21,7 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION(PeerConnectionTest);
 
 void PeerConnectionTest::testReserveBuffer() {
-  PeerConnection con(1, SharedHandle<Peer>(), SharedHandle<SocketCore>());
+  PeerConnection con(1, std::shared_ptr<Peer>(), std::shared_ptr<SocketCore>());
   con.presetBuffer((unsigned char*)"foo", 3);
   CPPUNIT_ASSERT_EQUAL((size_t)MAX_BUFFER_CAPACITY, con.getBufferCapacity());
   CPPUNIT_ASSERT_EQUAL((size_t)3, con.getBufferLength());
diff --git a/test/PeerSessionResourceTest.cc b/test/PeerSessionResourceTest.cc
index ba5ed418..8547e1dd 100644
--- a/test/PeerSessionResourceTest.cc
+++ b/test/PeerSessionResourceTest.cc
@@ -253,7 +253,7 @@ void PeerSessionResourceTest::testShouldBeChoking()
 void PeerSessionResourceTest::testCountOutstandingRequest()
 {
   PeerSessionResource res(1024, 1024*1024);
-  SharedHandle<MockBtMessageDispatcher> dispatcher
+  std::shared_ptr<MockBtMessageDispatcher> dispatcher
     (new MockBtMessageDispatcher());
   res.setBtMessageDispatcher(dispatcher.get());
 
diff --git a/test/PeerTest.cc b/test/PeerTest.cc
index c88078e2..dd86a945 100644
--- a/test/PeerTest.cc
+++ b/test/PeerTest.cc
@@ -11,7 +11,7 @@ class PeerTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testCountSeeder);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<Peer> peer;
+  std::shared_ptr<Peer> peer;
 public:
   void setUp() {
     peer.reset(new Peer("localhost", 6969));
@@ -40,13 +40,13 @@ void PeerTest::testAmAllowedIndexSet() {
 
 void PeerTest::testCountSeeder()
 {
-  std::vector<SharedHandle<Peer> > peers(5);
+  std::vector<std::shared_ptr<Peer> > peers(5);
   peers[0].reset(new Peer("192.168.0.1", 7000));
   peers[1].reset(new Peer("192.168.0.2", 7000));
   peers[2].reset(new Peer("192.168.0.3", 7000));
   peers[3].reset(new Peer("192.168.0.4", 7000));
   peers[4].reset(new Peer("192.168.0.5", 7000));
-  for(std::vector<SharedHandle<Peer> >::iterator i = peers.begin();
+  for(std::vector<std::shared_ptr<Peer> >::iterator i = peers.begin();
       i != peers.end(); ++i) {
     (*i)->allocateSessionResource(1024, 1024*8);
   }
diff --git a/test/PieceTest.cc b/test/PieceTest.cc
index be8354ba..6f9b9cf3 100644
--- a/test/PieceTest.cc
+++ b/test/PieceTest.cc
@@ -27,8 +27,8 @@ class PieceTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<DirectDiskAdaptor> adaptor_;
-  SharedHandle<ByteArrayDiskWriter> writer_;
+  std::shared_ptr<DirectDiskAdaptor> adaptor_;
+  std::shared_ptr<ByteArrayDiskWriter> writer_;
 public:
   void setUp()
   {
diff --git a/test/PriorityPieceSelectorTest.cc b/test/PriorityPieceSelectorTest.cc
index 5ebb90ff..714cf573 100644
--- a/test/PriorityPieceSelectorTest.cc
+++ b/test/PriorityPieceSelectorTest.cc
@@ -29,7 +29,7 @@ void PriorityPieceSelectorTest::testSelect()
     bf.setBit(A[i]);
   }
   PriorityPieceSelector selector
-    (SharedHandle<PieceSelector>(new MockPieceSelector()));
+    (std::shared_ptr<PieceSelector>(new MockPieceSelector()));
   selector.setPriorityPiece(vbegin(A), vend(A));
 
   size_t index;
diff --git a/test/RarestPieceSelectorTest.cc b/test/RarestPieceSelectorTest.cc
index f172b70d..a6b03b02 100644
--- a/test/RarestPieceSelectorTest.cc
+++ b/test/RarestPieceSelectorTest.cc
@@ -29,7 +29,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(RarestPieceSelectorTest);
 
 void RarestPieceSelectorTest::testSelect()
 {
-  SharedHandle<PieceStatMan> pieceStatMan(new PieceStatMan(10, false));
+  std::shared_ptr<PieceStatMan> pieceStatMan(new PieceStatMan(10, false));
   RarestPieceSelector selector(pieceStatMan);
   BitfieldMan bf(1024, 10*1024);
   bf.setBitRange(0, 2);
diff --git a/test/RequestGroupManTest.cc b/test/RequestGroupManTest.cc
index f4077e8a..241ab49a 100644
--- a/test/RequestGroupManTest.cc
+++ b/test/RequestGroupManTest.cc
@@ -37,9 +37,9 @@ class RequestGroupManTest : public CppUnit::TestFixture {
   CPPUNIT_TEST(testAddDownloadResult);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<DownloadEngine> e_;
-  SharedHandle<Option> option_;
-  SharedHandle<RequestGroupMan> rgman_;
+  std::shared_ptr<DownloadEngine> e_;
+  std::shared_ptr<Option> option_;
+  std::shared_ptr<RequestGroupMan> rgman_;
 public:
   void setUp()
   {
@@ -49,10 +49,10 @@ public:
     option_->put(PREF_ENABLE_RPC, A2_V_TRUE);
     File(option_->get(PREF_DIR)).mkdirs();
     e_.reset
-      (new DownloadEngine(SharedHandle<EventPoll>(new SelectEventPoll())));
+      (new DownloadEngine(std::shared_ptr<EventPoll>(new SelectEventPoll())));
     e_->setOption(option_.get());
-    rgman_ = SharedHandle<RequestGroupMan>
-      (new RequestGroupMan(std::vector<SharedHandle<RequestGroup> >(),
+    rgman_ = std::shared_ptr<RequestGroupMan>
+      (new RequestGroupMan(std::vector<std::shared_ptr<RequestGroup> >(),
                            3, option_.get()));
     e_->setRequestGroupMan(rgman_);
   }
@@ -73,20 +73,20 @@ CPPUNIT_TEST_SUITE_REGISTRATION( RequestGroupManTest );
 
 void RequestGroupManTest::testIsSameFileBeingDownloaded()
 {
-  SharedHandle<RequestGroup> rg1(new RequestGroup(GroupId::create(),
+  std::shared_ptr<RequestGroup> rg1(new RequestGroup(GroupId::create(),
                                                   util::copy(option_)));
-  SharedHandle<RequestGroup> rg2(new RequestGroup(GroupId::create(),
+  std::shared_ptr<RequestGroup> rg2(new RequestGroup(GroupId::create(),
                                                   util::copy(option_)));
 
-  SharedHandle<DownloadContext> dctx1
+  std::shared_ptr<DownloadContext> dctx1
     (new DownloadContext(0, 0, "aria2.tar.bz2"));
-  SharedHandle<DownloadContext> dctx2
+  std::shared_ptr<DownloadContext> dctx2
     (new DownloadContext(0, 0, "aria2.tar.bz2"));
 
   rg1->setDownloadContext(dctx1);
   rg2->setDownloadContext(dctx2);
 
-  RequestGroupMan gm(std::vector<SharedHandle<RequestGroup> >(), 1,
+  RequestGroupMan gm(std::vector<std::shared_ptr<RequestGroup> >(), 1,
                      option_.get());
 
   gm.addRequestGroup(rg1);
@@ -108,8 +108,8 @@ void RequestGroupManTest::testGetInitialCommands()
 void RequestGroupManTest::testSaveServerStat()
 {
   RequestGroupMan rm
-    (std::vector<SharedHandle<RequestGroup> >(),0,option_.get());
-  SharedHandle<ServerStat> ss_localhost(new ServerStat("localhost", "http"));
+    (std::vector<std::shared_ptr<RequestGroup> >(),0,option_.get());
+  std::shared_ptr<ServerStat> ss_localhost(new ServerStat("localhost", "http"));
   rm.addServerStat(ss_localhost);
   File f(A2_TEST_OUT_DIR"/aria2_RequestGroupManTest_testSaveServerStat");
   if(f.exists()) {
@@ -132,10 +132,10 @@ void RequestGroupManTest::testLoadServerStat()
   o.close();
 
   RequestGroupMan rm
-    (std::vector<SharedHandle<RequestGroup> >(),0,option_.get());
+    (std::vector<std::shared_ptr<RequestGroup> >(),0,option_.get());
   std::cerr << "testLoadServerStat" << std::endl;
   CPPUNIT_ASSERT(rm.loadServerStat(f.getPath()));
-  SharedHandle<ServerStat> ss_localhost = rm.findServerStat("localhost",
+  std::shared_ptr<ServerStat> ss_localhost = rm.findServerStat("localhost",
                                                             "http");
   CPPUNIT_ASSERT(ss_localhost);
   CPPUNIT_ASSERT_EQUAL(std::string("localhost"), ss_localhost->getHostname());
@@ -143,17 +143,17 @@ void RequestGroupManTest::testLoadServerStat()
 
 void RequestGroupManTest::testChangeReservedGroupPosition()
 {
-  SharedHandle<RequestGroup> gs[] = {
-    SharedHandle<RequestGroup>(new RequestGroup(GroupId::create(),
+  std::shared_ptr<RequestGroup> gs[] = {
+    std::shared_ptr<RequestGroup>(new RequestGroup(GroupId::create(),
                                                 util::copy(option_))),
-    SharedHandle<RequestGroup>(new RequestGroup(GroupId::create(),
+    std::shared_ptr<RequestGroup>(new RequestGroup(GroupId::create(),
                                                 util::copy(option_))),
-    SharedHandle<RequestGroup>(new RequestGroup(GroupId::create(),
+    std::shared_ptr<RequestGroup>(new RequestGroup(GroupId::create(),
                                                 util::copy(option_))),
-    SharedHandle<RequestGroup>(new RequestGroup(GroupId::create(),
+    std::shared_ptr<RequestGroup>(new RequestGroup(GroupId::create(),
                                                 util::copy(option_)))
   };
-  std::vector<SharedHandle<RequestGroup> > groups(vbegin(gs), vend(gs));
+  std::vector<std::shared_ptr<RequestGroup> > groups(vbegin(gs), vend(gs));
   RequestGroupMan rm(groups, 0, option_.get());
 
   CPPUNIT_ASSERT_EQUAL
@@ -217,7 +217,7 @@ void RequestGroupManTest::testChangeReservedGroupPosition()
 
 void RequestGroupManTest::testFillRequestGroupFromReserver()
 {
-  SharedHandle<RequestGroup> rgs[] = {
+  std::shared_ptr<RequestGroup> rgs[] = {
     createRequestGroup(0, 0, "foo1", "http://host/foo1", util::copy(option_)),
     createRequestGroup(0, 0, "foo2", "http://host/foo2", util::copy(option_)),
     createRequestGroup(0, 0, "foo3", "http://host/foo3", util::copy(option_)),
@@ -228,7 +228,7 @@ void RequestGroupManTest::testFillRequestGroupFromReserver()
     createRequestGroup(0, 0, "foo5", "http://host/foo5", util::copy(option_))
   };
   rgs[1]->setPauseRequested(true);
-  for(SharedHandle<RequestGroup>* i = vbegin(rgs); i != vend(rgs); ++i) {
+  for(std::shared_ptr<RequestGroup>* i = vbegin(rgs); i != vend(rgs); ++i) {
     rgman_->addReservedGroup(*i);
   }
   rgman_->fillRequestGroupFromReserver(e_.get());
@@ -238,16 +238,16 @@ void RequestGroupManTest::testFillRequestGroupFromReserver()
 
 void RequestGroupManTest::testFillRequestGroupFromReserver_uriParser()
 {
-  SharedHandle<RequestGroup> rgs[] = {
+  std::shared_ptr<RequestGroup> rgs[] = {
     createRequestGroup(0, 0, "mem1", "http://mem1", util::copy(option_)),
     createRequestGroup(0, 0, "mem2", "http://mem2", util::copy(option_)),
   };
   rgs[0]->setPauseRequested(true);
-  for(SharedHandle<RequestGroup>* i = vbegin(rgs); i != vend(rgs); ++i) {
+  for(std::shared_ptr<RequestGroup>* i = vbegin(rgs); i != vend(rgs); ++i) {
     rgman_->addReservedGroup(*i);
   }
 
-  SharedHandle<UriListParser> flp
+  std::shared_ptr<UriListParser> flp
     (new UriListParser(A2_TEST_DIR"/filelist2.txt"));
   rgman_->setUriListParser(flp);
 
@@ -262,19 +262,19 @@ void RequestGroupManTest::testFillRequestGroupFromReserver_uriParser()
 
 void RequestGroupManTest::testInsertReservedGroup()
 {
-  SharedHandle<RequestGroup> rgs1[] = {
-    SharedHandle<RequestGroup>(new RequestGroup(GroupId::create(),
+  std::shared_ptr<RequestGroup> rgs1[] = {
+    std::shared_ptr<RequestGroup>(new RequestGroup(GroupId::create(),
                                                 util::copy(option_))),
-    SharedHandle<RequestGroup>(new RequestGroup(GroupId::create(),
+    std::shared_ptr<RequestGroup>(new RequestGroup(GroupId::create(),
                                                 util::copy(option_)))
   };
-  SharedHandle<RequestGroup> rgs2[] = {
-    SharedHandle<RequestGroup>(new RequestGroup(GroupId::create(),
+  std::shared_ptr<RequestGroup> rgs2[] = {
+    std::shared_ptr<RequestGroup>(new RequestGroup(GroupId::create(),
                                                 util::copy(option_))),
-    SharedHandle<RequestGroup>(new RequestGroup(GroupId::create(),
+    std::shared_ptr<RequestGroup>(new RequestGroup(GroupId::create(),
                                                 util::copy(option_)))
   };
-  std::vector<SharedHandle<RequestGroup> > groups(vbegin(rgs1), vend(rgs1));
+  std::vector<std::shared_ptr<RequestGroup> > groups(vbegin(rgs1), vend(rgs1));
   rgman_->insertReservedGroup(0, groups);
   CPPUNIT_ASSERT_EQUAL((size_t)2, rgman_->getReservedGroups().size());
   RequestGroupList::const_iterator itr;
diff --git a/test/RequestGroupTest.cc b/test/RequestGroupTest.cc
index 7e6de0b5..32bce1d0 100644
--- a/test/RequestGroupTest.cc
+++ b/test/RequestGroupTest.cc
@@ -17,7 +17,7 @@ class RequestGroupTest : public CppUnit::TestFixture {
   CPPUNIT_TEST(testCreateDownloadResult);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<Option> option_;
+  std::shared_ptr<Option> option_;
 public:
   void setUp()
   {
@@ -33,7 +33,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( RequestGroupTest );
 
 void RequestGroupTest::testGetFirstFilePath()
 {
-  SharedHandle<DownloadContext> ctx
+  std::shared_ptr<DownloadContext> ctx
     (new DownloadContext(1024, 1024, "/tmp/myfile"));
 
   RequestGroup group(GroupId::create(), option_);
@@ -48,13 +48,13 @@ void RequestGroupTest::testGetFirstFilePath()
 
 void RequestGroupTest::testCreateDownloadResult()
 {
-  SharedHandle<DownloadContext> ctx
+  std::shared_ptr<DownloadContext> ctx
     (new DownloadContext(1024, 1024*1024, "/tmp/myfile"));
   RequestGroup group(GroupId::create(), option_);
   group.setDownloadContext(ctx);
   group.initPieceStorage();
   {
-    SharedHandle<DownloadResult> result = group.createDownloadResult();
+    std::shared_ptr<DownloadResult> result = group.createDownloadResult();
 
     CPPUNIT_ASSERT_EQUAL(std::string("/tmp/myfile"),
                          result->fileEntries[0]->getPath());
@@ -80,14 +80,14 @@ void RequestGroupTest::testCreateDownloadResult()
   {
     group.setLastErrorCode(error_code::RESOURCE_NOT_FOUND);
 
-    SharedHandle<DownloadResult> result = group.createDownloadResult();
+    std::shared_ptr<DownloadResult> result = group.createDownloadResult();
 
     CPPUNIT_ASSERT_EQUAL(error_code::RESOURCE_NOT_FOUND, result->result);
   }
   {
     group.getPieceStorage()->markAllPiecesDone();
 
-    SharedHandle<DownloadResult> result = group.createDownloadResult();
+    std::shared_ptr<DownloadResult> result = group.createDownloadResult();
 
     CPPUNIT_ASSERT_EQUAL(error_code::FINISHED, result->result);
   }
diff --git a/test/RpcMethodTest.cc b/test/RpcMethodTest.cc
index 9af0c762..9331e664 100644
--- a/test/RpcMethodTest.cc
+++ b/test/RpcMethodTest.cc
@@ -79,8 +79,8 @@ class RpcMethodTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testSystemMulticall_fail);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<DownloadEngine> e_;
-  SharedHandle<Option> option_;
+  std::shared_ptr<DownloadEngine> e_;
+  std::shared_ptr<Option> option_;
 public:
   void setUp()
   {
@@ -90,11 +90,11 @@ public:
     option_->put(PREF_MAX_DOWNLOAD_RESULT, "10");
     File(option_->get(PREF_DIR)).mkdirs();
     e_.reset
-      (new DownloadEngine(SharedHandle<EventPoll>(new SelectEventPoll())));
+      (new DownloadEngine(std::shared_ptr<EventPoll>(new SelectEventPoll())));
     e_->setOption(option_.get());
     e_->setRequestGroupMan
-      (SharedHandle<RequestGroupMan>
-       (new RequestGroupMan(std::vector<SharedHandle<RequestGroup> >(),
+      (std::shared_ptr<RequestGroupMan>
+       (new RequestGroupMan(std::vector<std::shared_ptr<RequestGroup> >(),
                             1, option_.get())));
   }
 
@@ -158,7 +158,7 @@ void RpcMethodTest::testAddUri()
 {
   AddUriRpcMethod m;
   RpcRequest req(AddUriRpcMethod::getMethodName(), List::g());
-  SharedHandle<List> urisParam = List::g();
+  std::shared_ptr<List> urisParam = List::g();
   urisParam->append("http://localhost/");
   req.params->append(urisParam);
   {
@@ -172,7 +172,7 @@ void RpcMethodTest::testAddUri()
                          getFirstFileEntry()->getRemainingUris().front());
   }
   // with options
-  SharedHandle<Dict> opt = Dict::g();
+  std::shared_ptr<Dict> opt = Dict::g();
   opt->put(PREF_DIR->k, "/sink");
   req.params->append(opt);
   {
@@ -199,7 +199,7 @@ void RpcMethodTest::testAddUri_notUri()
 {
   AddUriRpcMethod m;
   RpcRequest req(AddUriRpcMethod::getMethodName(), List::g());
-  SharedHandle<List> urisParam = List::g();
+  std::shared_ptr<List> urisParam = List::g();
   urisParam->append("not uri");
   req.params->append(urisParam);
   RpcResponse res = m.execute(req, e_.get());
@@ -210,10 +210,10 @@ void RpcMethodTest::testAddUri_withBadOption()
 {
   AddUriRpcMethod m;
   RpcRequest req(AddUriRpcMethod::getMethodName(), List::g());
-  SharedHandle<List> urisParam = List::g();
+  std::shared_ptr<List> urisParam = List::g();
   urisParam->append("http://localhost");
   req.params->append(urisParam);
-  SharedHandle<Dict> opt = Dict::g();
+  std::shared_ptr<Dict> opt = Dict::g();
   opt->put(PREF_FILE_ALLOCATION->k, "badvalue");
   req.params->append(opt);
   RpcResponse res = m.execute(req, e_.get());
@@ -224,14 +224,14 @@ void RpcMethodTest::testAddUri_withPosition()
 {
   AddUriRpcMethod m;
   RpcRequest req1(AddUriRpcMethod::getMethodName(), List::g());
-  SharedHandle<List> urisParam1 = List::g();
+  std::shared_ptr<List> urisParam1 = List::g();
   urisParam1->append("http://uri1");
   req1.params->append(urisParam1);
   RpcResponse res1 = m.execute(req1, e_.get());
   CPPUNIT_ASSERT_EQUAL(0, res1.code);
 
   RpcRequest req2(AddUriRpcMethod::getMethodName(), List::g());
-  SharedHandle<List> urisParam2 = List::g();
+  std::shared_ptr<List> urisParam2 = List::g();
   urisParam2->append("http://uri2");
   req2.params->append(urisParam2);
   req2.params->append(Dict::g());
@@ -249,7 +249,7 @@ void RpcMethodTest::testAddUri_withBadPosition()
 {
   AddUriRpcMethod m;
   RpcRequest req(AddUriRpcMethod::getMethodName(), List::g());
-  SharedHandle<List> urisParam = List::g();
+  std::shared_ptr<List> urisParam = List::g();
   urisParam->append("http://localhost/");
   req.params->append(urisParam);
   req.params->append(Dict::g());
@@ -266,7 +266,7 @@ void RpcMethodTest::testAddTorrent()
   AddTorrentRpcMethod m;
   RpcRequest req(AddTorrentRpcMethod::getMethodName(), List::g());
   req.params->append(readFile(A2_TEST_DIR"/single.torrent"));
-  SharedHandle<List> uris = List::g();
+  std::shared_ptr<List> uris = List::g();
   uris->append("http://localhost/aria2-0.8.2.tar.bz2");
   req.params->append(uris);
   {
@@ -290,7 +290,7 @@ void RpcMethodTest::testAddTorrent()
     CPPUNIT_ASSERT_EQUAL(0, GroupId::toNumericId
                          (gid, downcast<String>(res.param)->s().c_str()));
 
-    SharedHandle<RequestGroup> group =
+    std::shared_ptr<RequestGroup> group =
       findReservedGroup(e_->getRequestGroupMan(), gid);
     CPPUNIT_ASSERT(group);
     CPPUNIT_ASSERT_EQUAL(e_->getOption()->get(PREF_DIR)+"/aria2-0.8.2.tar.bz2",
@@ -305,7 +305,7 @@ void RpcMethodTest::testAddTorrent()
   // with options
   std::string dir = A2_TEST_OUT_DIR"/aria2_RpcMethodTest_testAddTorrent";
   File(dir).mkdirs();
-  SharedHandle<Dict> opt = Dict::g();
+  std::shared_ptr<Dict> opt = Dict::g();
   opt->put(PREF_DIR->k, dir);
   File(dir+"/0a3893293e27ac0490424c06de4d09242215f0a6.torrent").remove();
   req.params->append(opt);
@@ -408,12 +408,12 @@ void RpcMethodTest::testAddMetalink()
             "/c908634fbc257fd56f0114912c2772aeeb4064f4.meta4").exists());
 #endif // ENABLE_MESSAGE_DIGEST
 
-    SharedHandle<RequestGroup> tar =
+    std::shared_ptr<RequestGroup> tar =
       findReservedGroup(e_->getRequestGroupMan(), gid3);
     CPPUNIT_ASSERT(tar);
     CPPUNIT_ASSERT_EQUAL(e_->getOption()->get(PREF_DIR)+"/aria2-5.0.0.tar.bz2",
                          tar->getFirstFilePath());
-    SharedHandle<RequestGroup> deb =
+    std::shared_ptr<RequestGroup> deb =
       findReservedGroup(e_->getRequestGroupMan(), gid4);
     CPPUNIT_ASSERT(deb);
     CPPUNIT_ASSERT_EQUAL(e_->getOption()->get(PREF_DIR)+"/aria2-5.0.0.deb",
@@ -422,7 +422,7 @@ void RpcMethodTest::testAddMetalink()
   // with options
   std::string dir = A2_TEST_OUT_DIR"/aria2_RpcMethodTest_testAddMetalink";
   File(dir).mkdirs();
-  SharedHandle<Dict> opt = Dict::g();
+  std::shared_ptr<Dict> opt = Dict::g();
   opt->put(PREF_DIR->k, dir);
   File(dir+"/c908634fbc257fd56f0114912c2772aeeb4064f4.meta4").remove();
   req.params->append(opt);
@@ -466,7 +466,7 @@ void RpcMethodTest::testAddMetalink_withPosition()
 {
   AddUriRpcMethod m1;
   RpcRequest req1(AddUriRpcMethod::getMethodName(), List::g());
-  SharedHandle<List> urisParam1 = List::g();
+  std::shared_ptr<List> urisParam1 = List::g();
   urisParam1->append("http://uri");
   req1.params->append(urisParam1);
   RpcResponse res1 = m1.execute(req1, e_.get());
@@ -489,11 +489,11 @@ void RpcMethodTest::testAddMetalink_withPosition()
 
 void RpcMethodTest::testGetOption()
 {
-  SharedHandle<RequestGroup> group(new RequestGroup(GroupId::create(),
+  std::shared_ptr<RequestGroup> group(new RequestGroup(GroupId::create(),
                                                     option_));
   group->getOption()->put(PREF_DIR, "alpha");
   e_->getRequestGroupMan()->addReservedGroup(group);
-  SharedHandle<DownloadResult> dr = createDownloadResult(error_code::FINISHED,
+  std::shared_ptr<DownloadResult> dr = createDownloadResult(error_code::FINISHED,
                                                          "http://host/fin");
   dr->option->put(PREF_DIR, "bravo");
   e_->getRequestGroupMan()->addDownloadResult(dr);
@@ -523,28 +523,28 @@ void RpcMethodTest::testGetOption()
 
 void RpcMethodTest::testChangeOption()
 {
-  SharedHandle<RequestGroup> group(new RequestGroup(GroupId::create(),
+  std::shared_ptr<RequestGroup> group(new RequestGroup(GroupId::create(),
                                                     option_));
   e_->getRequestGroupMan()->addReservedGroup(group);
 
   ChangeOptionRpcMethod m;
   RpcRequest req(ChangeOptionRpcMethod::getMethodName(), List::g());
   req.params->append(GroupId::toHex(group->getGID()));
-  SharedHandle<Dict> opt = Dict::g();
+  std::shared_ptr<Dict> opt = Dict::g();
   opt->put(PREF_MAX_DOWNLOAD_LIMIT->k, "100K");
 #ifdef ENABLE_BITTORRENT
   opt->put(PREF_BT_MAX_PEERS->k, "100");
   opt->put(PREF_BT_REQUEST_PEER_SPEED_LIMIT->k, "300K");
   opt->put(PREF_MAX_UPLOAD_LIMIT->k, "50K");
 
-  SharedHandle<BtObject> btObject(new BtObject());
-  btObject->btRuntime = SharedHandle<BtRuntime>(new BtRuntime());
+  std::shared_ptr<BtObject> btObject(new BtObject());
+  btObject->btRuntime = std::shared_ptr<BtRuntime>(new BtRuntime());
   e_->getBtRegistry()->put(group->getGID(), btObject);
 #endif // ENABLE_BITTORRENT
   req.params->append(opt);
   RpcResponse res = m.execute(req, e_.get());
 
-  SharedHandle<Option> option = group->getOption();
+  std::shared_ptr<Option> option = group->getOption();
 
   CPPUNIT_ASSERT_EQUAL(0, res.code);
   CPPUNIT_ASSERT_EQUAL(100*1024,
@@ -567,14 +567,14 @@ void RpcMethodTest::testChangeOption()
 
 void RpcMethodTest::testChangeOption_withBadOption()
 {
-  SharedHandle<RequestGroup> group(new RequestGroup(GroupId::create(),
+  std::shared_ptr<RequestGroup> group(new RequestGroup(GroupId::create(),
                                                     option_));
   e_->getRequestGroupMan()->addReservedGroup(group);
 
   ChangeOptionRpcMethod m;
   RpcRequest req(ChangeOptionRpcMethod::getMethodName(), List::g());
   req.params->append(GroupId::toHex(group->getGID()));
-  SharedHandle<Dict> opt = Dict::g();
+  std::shared_ptr<Dict> opt = Dict::g();
   opt->put(PREF_MAX_DOWNLOAD_LIMIT->k, "badvalue");
   req.params->append(opt);
   RpcResponse res = m.execute(req, e_.get());
@@ -583,14 +583,14 @@ void RpcMethodTest::testChangeOption_withBadOption()
 
 void RpcMethodTest::testChangeOption_withNotAllowedOption()
 {
-  SharedHandle<RequestGroup> group(new RequestGroup(GroupId::create(),
+  std::shared_ptr<RequestGroup> group(new RequestGroup(GroupId::create(),
                                                     option_));
   e_->getRequestGroupMan()->addReservedGroup(group);
 
   ChangeOptionRpcMethod m;
   RpcRequest req(ChangeOptionRpcMethod::getMethodName(), List::g());
   req.params->append(GroupId::toHex(group->getGID()));
-  SharedHandle<Dict> opt = Dict::g();
+  std::shared_ptr<Dict> opt = Dict::g();
   opt->put(PREF_MAX_OVERALL_DOWNLOAD_LIMIT->k, "100K");
   req.params->append(opt);
   RpcResponse res = m.execute(req, e_.get());
@@ -611,7 +611,7 @@ void RpcMethodTest::testChangeGlobalOption()
   ChangeGlobalOptionRpcMethod m;
   RpcRequest req
     (ChangeGlobalOptionRpcMethod::getMethodName(), List::g());
-  SharedHandle<Dict> opt = Dict::g();
+  std::shared_ptr<Dict> opt = Dict::g();
   opt->put(PREF_MAX_OVERALL_DOWNLOAD_LIMIT->k, "100K");
 #ifdef ENABLE_BITTORRENT
   opt->put(PREF_MAX_OVERALL_UPLOAD_LIMIT->k, "50K");
@@ -639,7 +639,7 @@ void RpcMethodTest::testChangeGlobalOption_withBadOption()
   ChangeGlobalOptionRpcMethod m;
   RpcRequest req
     (ChangeGlobalOptionRpcMethod::getMethodName(), List::g());
-  SharedHandle<Dict> opt = Dict::g();
+  std::shared_ptr<Dict> opt = Dict::g();
   opt->put(PREF_MAX_OVERALL_DOWNLOAD_LIMIT->k, "badvalue");
   req.params->append(opt);
   RpcResponse res = m.execute(req, e_.get());
@@ -651,7 +651,7 @@ void RpcMethodTest::testChangeGlobalOption_withNotAllowedOption()
   ChangeGlobalOptionRpcMethod m;
   RpcRequest req
     (ChangeGlobalOptionRpcMethod::getMethodName(), List::g());
-  SharedHandle<Dict> opt = Dict::g();
+  std::shared_ptr<Dict> opt = Dict::g();
   opt->put(PREF_ENABLE_RPC->k, "100K");
   req.params->append(opt);
   RpcResponse res = m.execute(req, e_.get());
@@ -678,11 +678,11 @@ void RpcMethodTest::testTellStatus_withoutGid()
 }
 
 namespace {
-void addUri(const std::string& uri, const SharedHandle<DownloadEngine>& e)
+void addUri(const std::string& uri, const std::shared_ptr<DownloadEngine>& e)
 {
   AddUriRpcMethod m;
   RpcRequest req(AddUriRpcMethod::getMethodName(), List::g());
-  SharedHandle<List> urisParam = List::g();
+  std::shared_ptr<List> urisParam = List::g();
   urisParam->append(uri);
   req.params->append(urisParam);
   CPPUNIT_ASSERT_EQUAL(0, m.execute(req, e.get()).code);
@@ -692,7 +692,7 @@ void addUri(const std::string& uri, const SharedHandle<DownloadEngine>& e)
 #ifdef ENABLE_BITTORRENT
 namespace {
 void addTorrent
-(const std::string& torrentFile, const SharedHandle<DownloadEngine>& e)
+(const std::string& torrentFile, const std::shared_ptr<DownloadEngine>& e)
 {
   AddTorrentRpcMethod m;
   RpcRequest req(AddTorrentRpcMethod::getMethodName(), List::g());
@@ -712,7 +712,7 @@ void RpcMethodTest::testTellWaiting()
 #else // !ENABLE_BITTORRENT
   addUri("http://4/", e_);
 #endif // !ENABLE_BITTORRENT
-  const SharedHandle<RequestGroupMan>& rgman = e_->getRequestGroupMan();
+  const std::shared_ptr<RequestGroupMan>& rgman = e_->getRequestGroupMan();
   TellWaitingRpcMethod m;
   RpcRequest req(TellWaitingRpcMethod::getMethodName(), List::g());
   req.params->append(Integer::g(1));
@@ -833,11 +833,11 @@ void RpcMethodTest::testGetVersion()
 
 void RpcMethodTest::testGatherStoppedDownload()
 {
-  std::vector<SharedHandle<FileEntry> > fileEntries;
+  std::vector<std::shared_ptr<FileEntry> > fileEntries;
   std::vector<a2_gid_t> followedBy;
   followedBy.push_back(3);
   followedBy.push_back(4);
-  SharedHandle<DownloadResult> d(new DownloadResult());
+  std::shared_ptr<DownloadResult> d(new DownloadResult());
   d->gid = GroupId::create();
   d->fileEntries = fileEntries;
   d->inMemoryDownload = false;
@@ -846,7 +846,7 @@ void RpcMethodTest::testGatherStoppedDownload()
   d->result = error_code::FINISHED;
   d->followedBy = followedBy;
   d->belongsTo = 2;
-  SharedHandle<Dict> entry = Dict::g();
+  std::shared_ptr<Dict> entry = Dict::g();
   std::vector<std::string> keys;
   gatherStoppedDownload(entry, d, keys);
 
@@ -868,24 +868,24 @@ void RpcMethodTest::testGatherStoppedDownload()
 
 void RpcMethodTest::testGatherProgressCommon()
 {
-  SharedHandle<DownloadContext> dctx(new DownloadContext(0, 0,"aria2.tar.bz2"));
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext(0, 0,"aria2.tar.bz2"));
   std::string uris[] = { "http://localhost/aria2.tar.bz2" };
   dctx->getFirstFileEntry()->addUris(vbegin(uris), vend(uris));
-  SharedHandle<RequestGroup> group(new RequestGroup(GroupId::create(),
+  std::shared_ptr<RequestGroup> group(new RequestGroup(GroupId::create(),
                                                     util::copy(option_)));
   group->setDownloadContext(dctx);
-  std::vector<SharedHandle<RequestGroup> > followedBy;
+  std::vector<std::shared_ptr<RequestGroup> > followedBy;
   for(int i = 0; i < 2; ++i) {
-    followedBy.push_back(SharedHandle<RequestGroup>
+    followedBy.push_back(std::shared_ptr<RequestGroup>
                          (new RequestGroup(GroupId::create(),
                                            util::copy(option_))));
   }
 
   group->followedBy(followedBy.begin(), followedBy.end());
-  SharedHandle<GroupId> parent = GroupId::create();
+  std::shared_ptr<GroupId> parent = GroupId::create();
   group->belongsTo(parent->getNumericId());
 
-  SharedHandle<Dict> entry = Dict::g();
+  std::shared_ptr<Dict> entry = Dict::g();
   std::vector<std::string> keys;
   gatherProgressCommon(entry, group, keys);
 
@@ -922,11 +922,11 @@ void RpcMethodTest::testGatherProgressCommon()
 #ifdef ENABLE_BITTORRENT
 void RpcMethodTest::testGatherBitTorrentMetadata()
 {
-  SharedHandle<Option> option(new Option());
+  std::shared_ptr<Option> option(new Option());
   option->put(PREF_DIR, ".");
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   bittorrent::load(A2_TEST_DIR"/test.torrent", dctx, option);
-  SharedHandle<Dict> btDict = Dict::g();
+  std::shared_ptr<Dict> btDict = Dict::g();
   gatherBitTorrentMetadata(btDict, bittorrent::getTorrentAttrs(dctx));
   CPPUNIT_ASSERT_EQUAL(std::string("REDNOAH.COM RULES"),
                        downcast<String>(btDict->get("comment"))->s());
@@ -949,7 +949,7 @@ void RpcMethodTest::testGatherBitTorrentMetadata()
   CPPUNIT_ASSERT_EQUAL(std::string("http://tracker3"),
                        downcast<String>(downcast<List>(announceList->get(2))->get(0))->s());
   // Remove some keys
-  SharedHandle<TorrentAttribute> modBtAttrs = bittorrent::getTorrentAttrs(dctx);
+  std::shared_ptr<TorrentAttribute> modBtAttrs = bittorrent::getTorrentAttrs(dctx);
   modBtAttrs->comment.clear();
   modBtAttrs->creationDate = 0;
   modBtAttrs->mode = BT_FILE_MODE_NONE;
@@ -967,10 +967,10 @@ void RpcMethodTest::testGatherBitTorrentMetadata()
 void RpcMethodTest::testChangePosition()
 {
   e_->getRequestGroupMan()->addReservedGroup
-    (SharedHandle<RequestGroup>(new RequestGroup(GroupId::create(),
+    (std::shared_ptr<RequestGroup>(new RequestGroup(GroupId::create(),
                                                  util::copy(option_))));
   e_->getRequestGroupMan()->addReservedGroup
-    (SharedHandle<RequestGroup>(new RequestGroup(GroupId::create(),
+    (std::shared_ptr<RequestGroup>(new RequestGroup(GroupId::create(),
                                                  util::copy(option_))));
 
   a2_gid_t gid = getReservedGroup(e_->getRequestGroupMan(), 0)->getGID();
@@ -1001,16 +1001,16 @@ void RpcMethodTest::testChangePosition_fail()
 
 void RpcMethodTest::testChangeUri()
 {
-  SharedHandle<FileEntry> files[3];
+  std::shared_ptr<FileEntry> files[3];
   for(int i = 0; i < 3; ++i) {
     files[i].reset(new FileEntry());
   }
   files[1]->addUri("http://example.org/aria2.tar.bz2");
   files[1]->addUri("http://example.org/mustremove1");
   files[1]->addUri("http://example.org/mustremove2");
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   dctx->setFileEntries(&files[0], &files[3]);
-  SharedHandle<RequestGroup> group(new RequestGroup(GroupId::create(),
+  std::shared_ptr<RequestGroup> group(new RequestGroup(GroupId::create(),
                                                     option_));
   group->setDownloadContext(dctx);
   e_->getRequestGroupMan()->addReservedGroup(group);
@@ -1019,12 +1019,12 @@ void RpcMethodTest::testChangeUri()
   RpcRequest req(ChangeUriRpcMethod::getMethodName(), List::g());
   req.params->append(GroupId::toHex(group->getGID())); // GID
   req.params->append(Integer::g(2)); // index of FileEntry
-  SharedHandle<List> removeuris = List::g();
+  std::shared_ptr<List> removeuris = List::g();
   removeuris->append("http://example.org/mustremove1");
   removeuris->append("http://example.org/mustremove2");
   removeuris->append("http://example.org/notexist");
   req.params->append(removeuris);
-  SharedHandle<List> adduris = List::g();
+  std::shared_ptr<List> adduris = List::g();
   adduris->append("http://example.org/added1");
   adduris->append("http://example.org/added2");
   adduris->append("baduri");
@@ -1075,13 +1075,13 @@ void RpcMethodTest::testChangeUri()
 
 void RpcMethodTest::testChangeUri_fail()
 {
-  SharedHandle<FileEntry> files[3];
+  std::shared_ptr<FileEntry> files[3];
   for(int i = 0; i < 3; ++i) {
     files[i].reset(new FileEntry());
   }
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   dctx->setFileEntries(&files[0], &files[3]);
-  SharedHandle<RequestGroup> group(new RequestGroup(GroupId::create(),
+  std::shared_ptr<RequestGroup> group(new RequestGroup(GroupId::create(),
                                                     option_));
   group->setDownloadContext(dctx);
   e_->getRequestGroupMan()->addReservedGroup(group);
@@ -1090,9 +1090,9 @@ void RpcMethodTest::testChangeUri_fail()
   RpcRequest req(ChangeUriRpcMethod::getMethodName(), List::g());
   req.params->append(GroupId::toHex(group->getGID())); // GID
   req.params->append(Integer::g(1)); // index of FileEntry
-  SharedHandle<List> removeuris = List::g();
+  std::shared_ptr<List> removeuris = List::g();
   req.params->append(removeuris);
-  SharedHandle<List> adduris = List::g();
+  std::shared_ptr<List> adduris = List::g();
   req.params->append(adduris);
   RpcResponse res = m.execute(req, e_.get());
   CPPUNIT_ASSERT_EQUAL(0, res.code);
@@ -1151,7 +1151,7 @@ void RpcMethodTest::testPause()
   };
   std::vector<std::string> uris(vbegin(URIS), vend(URIS));
   option_->put(PREF_FORCE_SEQUENTIAL, A2_V_TRUE);
-  std::vector<SharedHandle<RequestGroup> > groups;
+  std::vector<std::shared_ptr<RequestGroup> > groups;
   createRequestGroupForUri(groups, option_, uris);
   CPPUNIT_ASSERT_EQUAL((size_t)3, groups.size());
   e_->getRequestGroupMan()->addReservedGroup(groups);
@@ -1204,20 +1204,20 @@ void RpcMethodTest::testSystemMulticall()
 {
   SystemMulticallRpcMethod m;
   RpcRequest req("system.multicall", List::g());
-  SharedHandle<List> reqparams = List::g();
+  std::shared_ptr<List> reqparams = List::g();
   req.params->append(reqparams);
   for(int i = 0; i < 2; ++i) {
-    SharedHandle<Dict> dict = Dict::g();
+    std::shared_ptr<Dict> dict = Dict::g();
     dict->put("methodName", AddUriRpcMethod::getMethodName());
-    SharedHandle<List> params = List::g();
-    SharedHandle<List> urisParam = List::g();
+    std::shared_ptr<List> params = List::g();
+    std::shared_ptr<List> urisParam = List::g();
     urisParam->append("http://localhost/"+util::itos(i));
     params->append(urisParam);
     dict->put("params", params);
     reqparams->append(dict);
   }
   {
-    SharedHandle<Dict> dict = Dict::g();
+    std::shared_ptr<Dict> dict = Dict::g();
     dict->put("methodName", "not exists");
     dict->put("params", List::g());
     reqparams->append(dict);
@@ -1226,19 +1226,19 @@ void RpcMethodTest::testSystemMulticall()
     reqparams->append("not struct");
   }
   {
-    SharedHandle<Dict> dict = Dict::g();
+    std::shared_ptr<Dict> dict = Dict::g();
     dict->put("methodName", "system.multicall");
     dict->put("params", List::g());
     reqparams->append(dict);
   }
   {
     // missing params
-    SharedHandle<Dict> dict = Dict::g();
+    std::shared_ptr<Dict> dict = Dict::g();
     dict->put("methodName", GetVersionRpcMethod::getMethodName());
     reqparams->append(dict);
   }
   {
-    SharedHandle<Dict> dict = Dict::g();
+    std::shared_ptr<Dict> dict = Dict::g();
     dict->put("methodName", GetVersionRpcMethod::getMethodName());
     dict->put("params", List::g());
     reqparams->append(dict);
@@ -1247,7 +1247,7 @@ void RpcMethodTest::testSystemMulticall()
   CPPUNIT_ASSERT_EQUAL(0, res.code);
   const List* resParams = downcast<List>(res.param);
   CPPUNIT_ASSERT_EQUAL((size_t)7, resParams->size());
-  SharedHandle<RequestGroupMan> rgman = e_->getRequestGroupMan();
+  std::shared_ptr<RequestGroupMan> rgman = e_->getRequestGroupMan();
   CPPUNIT_ASSERT_EQUAL(GroupId::toHex(getReservedGroup(rgman, 0)->getGID()),
                        downcast<String>(downcast<List>(resParams->get(0))->get(0))->s());
   CPPUNIT_ASSERT_EQUAL(GroupId::toHex(getReservedGroup(rgman, 1)->getGID()),
diff --git a/test/RpcResponseTest.cc b/test/RpcResponseTest.cc
index 9dadecff..6e4eb191 100644
--- a/test/RpcResponseTest.cc
+++ b/test/RpcResponseTest.cc
@@ -26,9 +26,9 @@ void RpcResponseTest::testToJson()
 {
   std::vector<RpcResponse> results;
   {
-    SharedHandle<List> param = List::g();
+    std::shared_ptr<List> param = List::g();
     param->append(Integer::g(1));
-    SharedHandle<String> id = String::g("9");
+    std::shared_ptr<String> id = String::g("9");
     RpcResponse res(0, param, id);
     results.push_back(res);
     std::string s = toJson(res, "", false);
@@ -45,7 +45,7 @@ void RpcResponseTest::testToJson()
   }
   {
     // error response
-    SharedHandle<Dict> param = Dict::g();
+    std::shared_ptr<Dict> param = Dict::g();
     param->put("code", Integer::g(1));
     param->put("message", "HELLO ERROR");
     RpcResponse res(1, param, Null::g());
@@ -99,7 +99,7 @@ void RpcResponseTest::testToJson()
 #ifdef ENABLE_XML_RPC
 void RpcResponseTest::testToXml()
 {
-  SharedHandle<Dict> param = Dict::g();
+  std::shared_ptr<Dict> param = Dict::g();
   param->put("faultCode", Integer::g(1));
   param->put("faultString", "No such method: make.hamburger");
   RpcResponse res(1, param, Null::g());
diff --git a/test/SegmentManTest.cc b/test/SegmentManTest.cc
index 7b9b2aad..0e1a2fc5 100644
--- a/test/SegmentManTest.cc
+++ b/test/SegmentManTest.cc
@@ -25,10 +25,10 @@ class SegmentManTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testGetCleanSegmentIfOwnerIsIdle);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<Option> option_;
-  SharedHandle<DownloadContext> dctx_;
-  SharedHandle<DefaultPieceStorage> pieceStorage_;
-  SharedHandle<SegmentMan> segmentMan_;
+  std::shared_ptr<Option> option_;
+  std::shared_ptr<DownloadContext> dctx_;
+  std::shared_ptr<DefaultPieceStorage> pieceStorage_;
+  std::shared_ptr<SegmentMan> segmentMan_;
 public:
   void setUp()
   {
@@ -56,21 +56,21 @@ CPPUNIT_TEST_SUITE_REGISTRATION( SegmentManTest );
 void SegmentManTest::testNullBitfield()
 {
   Option op;
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(0, 0, "aria2.tar.bz2"));
-  SharedHandle<UnknownLengthPieceStorage> ps
+  std::shared_ptr<UnknownLengthPieceStorage> ps
     (new UnknownLengthPieceStorage(dctx));
   SegmentMan segmentMan(dctx, ps);
   size_t minSplitSize = dctx->getPieceLength();
 
-  SharedHandle<Segment> segment = segmentMan.getSegment(1, minSplitSize);
+  std::shared_ptr<Segment> segment = segmentMan.getSegment(1, minSplitSize);
   CPPUNIT_ASSERT(segment);
   CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getIndex());
   CPPUNIT_ASSERT_EQUAL(0, segment->getLength());
   CPPUNIT_ASSERT_EQUAL(0, segment->getSegmentLength());
   CPPUNIT_ASSERT_EQUAL(0, segment->getWrittenLength());
 
-  SharedHandle<Segment> segment2 = segmentMan.getSegment(2, minSplitSize);
+  std::shared_ptr<Segment> segment2 = segmentMan.getSegment(2, minSplitSize);
   CPPUNIT_ASSERT(!segment2);
 
   segmentMan.cancelSegment(1);
@@ -82,21 +82,21 @@ void SegmentManTest::testCompleteSegment()
   Option op;
   size_t pieceLength = 1024*1024;
   uint64_t totalLength = 64*1024*1024;
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(pieceLength, totalLength, "aria2.tar.bz2"));
-  SharedHandle<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &op));
+  std::shared_ptr<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &op));
 
   SegmentMan segmentMan(dctx, ps);
 
   CPPUNIT_ASSERT(segmentMan.getSegmentWithIndex(1, 0));
-  SharedHandle<Segment> seg = segmentMan.getSegmentWithIndex(1, 1);
+  std::shared_ptr<Segment> seg = segmentMan.getSegmentWithIndex(1, 1);
   CPPUNIT_ASSERT(seg);
   CPPUNIT_ASSERT(segmentMan.getSegmentWithIndex(1, 2));
 
   seg->updateWrittenLength(pieceLength);
   segmentMan.completeSegment(1, seg);
 
-  std::vector<SharedHandle<Segment> > segments;
+  std::vector<std::shared_ptr<Segment> > segments;
   segmentMan.getInFlightSegment(segments, 1);
   CPPUNIT_ASSERT_EQUAL((size_t)2, segments.size());
   CPPUNIT_ASSERT_EQUAL((size_t)0, segments[0]->getIndex());
@@ -106,24 +106,24 @@ void SegmentManTest::testCompleteSegment()
 void SegmentManTest::testGetSegment_sameFileEntry()
 {
   Option op;
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
   dctx->setPieceLength(2);
-  SharedHandle<FileEntry> fileEntries[] = {
-    SharedHandle<FileEntry>(new FileEntry("file1", 3, 0)),
-    SharedHandle<FileEntry>(new FileEntry("file2", 6, 3)),
-    SharedHandle<FileEntry>(new FileEntry("file3", 1, 9))
+  std::shared_ptr<FileEntry> fileEntries[] = {
+    std::shared_ptr<FileEntry>(new FileEntry("file1", 3, 0)),
+    std::shared_ptr<FileEntry>(new FileEntry("file2", 6, 3)),
+    std::shared_ptr<FileEntry>(new FileEntry("file3", 1, 9))
   };
   dctx->setFileEntries(&fileEntries[0], &fileEntries[3]);
-  SharedHandle<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &op));
+  std::shared_ptr<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &op));
   SegmentMan segman(dctx, ps);
   size_t minSplitSize =dctx->getPieceLength();
-  std::vector<SharedHandle<Segment> > segments;
+  std::vector<std::shared_ptr<Segment> > segments;
   segman.getSegment(segments, 1, minSplitSize, fileEntries[1], 4);
   // See 3 segments are returned, not 4 because the part of file1 is
   // not filled in segment#1
   CPPUNIT_ASSERT_EQUAL((size_t)3, segments.size());
 
-  SharedHandle<Segment> segmentNo1 = segman.getSegmentWithIndex(2, 1);
+  std::shared_ptr<Segment> segmentNo1 = segman.getSegmentWithIndex(2, 1);
   // Fill the part of file1 in segment#1
   segmentNo1->updateWrittenLength(1);
   segman.cancelSegment(2);
@@ -134,7 +134,7 @@ void SegmentManTest::testGetSegment_sameFileEntry()
   CPPUNIT_ASSERT_EQUAL((size_t)4, segments.size());
 
   segman.cancelSegment(1);
-  SharedHandle<Segment> segmentNo4 = segman.getSegmentWithIndex(1, 4);
+  std::shared_ptr<Segment> segmentNo4 = segman.getSegmentWithIndex(1, 4);
   // Fill the part of file2 in segment#4
   segmentNo4->updateWrittenLength(1);
   segman.cancelSegment(1);
@@ -148,14 +148,14 @@ void SegmentManTest::testGetSegment_sameFileEntry()
 void SegmentManTest::testRegisterPeerStat()
 {
   Option op;
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
-  SharedHandle<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &op));
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &op));
   SegmentMan segman(dctx, ps);
 
-  SharedHandle<PeerStat> p1(new PeerStat(0, "host1", "http"));
+  std::shared_ptr<PeerStat> p1(new PeerStat(0, "host1", "http"));
   segman.registerPeerStat(p1);
   CPPUNIT_ASSERT_EQUAL((size_t)1, segman.getPeerStats().size());
-  SharedHandle<PeerStat> p2(new PeerStat(0, "host2", "http"));
+  std::shared_ptr<PeerStat> p2(new PeerStat(0, "host2", "http"));
   segman.registerPeerStat(p2);
   CPPUNIT_ASSERT_EQUAL((size_t)2, segman.getPeerStats().size());
 }
@@ -173,21 +173,21 @@ void SegmentManTest::testCancelAllSegments()
 
 void SegmentManTest::testGetPeerStat()
 {
-  SharedHandle<PeerStat> peerStat1(new PeerStat(1));
+  std::shared_ptr<PeerStat> peerStat1(new PeerStat(1));
   segmentMan_->registerPeerStat(peerStat1);
   CPPUNIT_ASSERT_EQUAL((cuid_t)1, segmentMan_->getPeerStat(1)->getCuid());
 }
 
 void SegmentManTest::testGetCleanSegmentIfOwnerIsIdle()
 {
-  SharedHandle<Segment> seg1 = segmentMan_->getSegmentWithIndex(1, 0);
-  SharedHandle<Segment> seg2 = segmentMan_->getSegmentWithIndex(2, 1);
+  std::shared_ptr<Segment> seg1 = segmentMan_->getSegmentWithIndex(1, 0);
+  std::shared_ptr<Segment> seg2 = segmentMan_->getSegmentWithIndex(2, 1);
   seg2->updateWrittenLength(100);
   CPPUNIT_ASSERT(segmentMan_->getCleanSegmentIfOwnerIsIdle(3, 0));
-  SharedHandle<PeerStat> peerStat3(new PeerStat(3));
+  std::shared_ptr<PeerStat> peerStat3(new PeerStat(3));
   segmentMan_->registerPeerStat(peerStat3);
   CPPUNIT_ASSERT(segmentMan_->getCleanSegmentIfOwnerIsIdle(4, 0));
-  SharedHandle<PeerStat> peerStat4(new PeerStat(4));
+  std::shared_ptr<PeerStat> peerStat4(new PeerStat(4));
   peerStat4->downloadStart();
   segmentMan_->registerPeerStat(peerStat4);
   // Owner PeerStat is not IDLE
diff --git a/test/SegmentTest.cc b/test/SegmentTest.cc
index 719c7459..061cb891 100644
--- a/test/SegmentTest.cc
+++ b/test/SegmentTest.cc
@@ -30,7 +30,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( SegmentTest );
 
 void SegmentTest::testUpdateWrittenLength()
 {
-  SharedHandle<Piece> p(new Piece(0, 16*1024*10));
+  std::shared_ptr<Piece> p(new Piece(0, 16*1024*10));
   PiecedSegment s(16*1024*10, p);
   CPPUNIT_ASSERT_EQUAL(0, s.getWrittenLength());
 
@@ -44,7 +44,7 @@ void SegmentTest::testUpdateWrittenLength()
 
 void SegmentTest::testUpdateWrittenLength_lastPiece()
 {
-  SharedHandle<Piece> p(new Piece(0, 16*1024*9+1));
+  std::shared_ptr<Piece> p(new Piece(0, 16*1024*9+1));
   PiecedSegment s(16*1024*10, p);
 
   s.updateWrittenLength(p->getLength());
@@ -53,7 +53,7 @@ void SegmentTest::testUpdateWrittenLength_lastPiece()
 
 void SegmentTest::testUpdateWrittenLength_incompleteLastPiece()
 {
-  SharedHandle<Piece> p(new Piece(0, 16*1024*9+2));
+  std::shared_ptr<Piece> p(new Piece(0, 16*1024*9+2));
   PiecedSegment s(16*1024*10, p);
 
   s.updateWrittenLength(16*1024*9+1);
@@ -64,7 +64,7 @@ void SegmentTest::testUpdateWrittenLength_incompleteLastPiece()
 
 void SegmentTest::testClear()
 {
-  SharedHandle<Piece> p(new Piece(0, 16*1024*10));
+  std::shared_ptr<Piece> p(new Piece(0, 16*1024*10));
   PiecedSegment s(16*1024*10, p);
   s.updateWrittenLength(16*1024*10);
   CPPUNIT_ASSERT_EQUAL(16*1024*10, s.getWrittenLength());
diff --git a/test/SequentialPickerTest.cc b/test/SequentialPickerTest.cc
index a598d91c..af7b948c 100644
--- a/test/SequentialPickerTest.cc
+++ b/test/SequentialPickerTest.cc
@@ -4,7 +4,7 @@
 
 namespace aria2 {
 
-typedef SharedHandle<int> Integer;
+typedef std::shared_ptr<int> Integer;
 
 class SequentialPickerTest:public CppUnit::TestFixture {
 
diff --git a/test/ServerStatManTest.cc b/test/ServerStatManTest.cc
index 130d7c89..8b016c85 100644
--- a/test/ServerStatManTest.cc
+++ b/test/ServerStatManTest.cc
@@ -36,9 +36,9 @@ CPPUNIT_TEST_SUITE_REGISTRATION(ServerStatManTest);
 
 void ServerStatManTest::testAddAndFind()
 {
-  SharedHandle<ServerStat> localhost_http(new ServerStat("localhost", "http"));
-  SharedHandle<ServerStat> localhost_ftp(new ServerStat("localhost", "ftp"));
-  SharedHandle<ServerStat> mirror(new ServerStat("mirror", "http"));
+  std::shared_ptr<ServerStat> localhost_http(new ServerStat("localhost", "http"));
+  std::shared_ptr<ServerStat> localhost_ftp(new ServerStat("localhost", "ftp"));
+  std::shared_ptr<ServerStat> mirror(new ServerStat("mirror", "http"));
 
   ServerStatMan ssm;
   CPPUNIT_ASSERT(ssm.add(localhost_http));
@@ -47,29 +47,29 @@ void ServerStatManTest::testAddAndFind()
   CPPUNIT_ASSERT(ssm.add(mirror));
 
   {
-    SharedHandle<ServerStat> r = ssm.find("localhost", "http");
+    std::shared_ptr<ServerStat> r = ssm.find("localhost", "http");
     CPPUNIT_ASSERT(r);
     CPPUNIT_ASSERT_EQUAL(std::string("localhost"), r->getHostname());
     CPPUNIT_ASSERT_EQUAL(std::string("http"), r->getProtocol());
   }
   {
-    SharedHandle<ServerStat> r = ssm.find("mirror", "ftp");
+    std::shared_ptr<ServerStat> r = ssm.find("mirror", "ftp");
     CPPUNIT_ASSERT(!r);
   }
 }
 
 void ServerStatManTest::testSave()
 {
-  SharedHandle<ServerStat> localhost_http(new ServerStat("localhost", "http"));
+  std::shared_ptr<ServerStat> localhost_http(new ServerStat("localhost", "http"));
   localhost_http->setDownloadSpeed(25000);
   localhost_http->setSingleConnectionAvgSpeed(100);
   localhost_http->setMultiConnectionAvgSpeed(101);
   localhost_http->setCounter(5);
   localhost_http->setLastUpdated(Time(1210000000));
-  SharedHandle<ServerStat> localhost_ftp(new ServerStat("localhost", "ftp"));
+  std::shared_ptr<ServerStat> localhost_ftp(new ServerStat("localhost", "ftp"));
   localhost_ftp->setDownloadSpeed(30000);
   localhost_ftp->setLastUpdated(Time(1210000001));
-  SharedHandle<ServerStat> mirror(new ServerStat("mirror", "http"));
+  std::shared_ptr<ServerStat> mirror(new ServerStat("mirror", "http"));
   mirror->setDownloadSpeed(0);
   mirror->setStatus(ServerStat::A2_ERROR);
   mirror->setLastUpdated(Time(1210000002));
@@ -123,7 +123,7 @@ void ServerStatManTest::testLoad()
   ServerStatMan ssm;
   CPPUNIT_ASSERT(ssm.load(filename));
 
-  SharedHandle<ServerStat> localhost_http = ssm.find("localhost", "http");
+  std::shared_ptr<ServerStat> localhost_http = ssm.find("localhost", "http");
   CPPUNIT_ASSERT(localhost_http);
   CPPUNIT_ASSERT_EQUAL(std::string("localhost"), localhost_http->getHostname());
   CPPUNIT_ASSERT_EQUAL(std::string("http"), localhost_http->getProtocol());
@@ -135,7 +135,7 @@ void ServerStatManTest::testLoad()
                        localhost_http->getLastUpdated().getTime());
   CPPUNIT_ASSERT_EQUAL(ServerStat::OK, localhost_http->getStatus());
 
-  SharedHandle<ServerStat> mirror = ssm.find("mirror", "http");
+  std::shared_ptr<ServerStat> mirror = ssm.find("mirror", "http");
   CPPUNIT_ASSERT(mirror);
   CPPUNIT_ASSERT_EQUAL(ServerStat::A2_ERROR, mirror->getStatus());
 }
@@ -143,13 +143,13 @@ void ServerStatManTest::testLoad()
 void ServerStatManTest::testRemoveStaleServerStat()
 {
   Time now;
-  SharedHandle<ServerStat> localhost_http(new ServerStat("localhost", "http"));
+  std::shared_ptr<ServerStat> localhost_http(new ServerStat("localhost", "http"));
   localhost_http->setDownloadSpeed(25000);
   localhost_http->setLastUpdated(now);
-  SharedHandle<ServerStat> localhost_ftp(new ServerStat("localhost", "ftp"));
+  std::shared_ptr<ServerStat> localhost_ftp(new ServerStat("localhost", "ftp"));
   localhost_ftp->setDownloadSpeed(30000);
   localhost_ftp->setLastUpdated(Time(1210000001));
-  SharedHandle<ServerStat> mirror(new ServerStat("mirror", "http"));
+  std::shared_ptr<ServerStat> mirror(new ServerStat("mirror", "http"));
   mirror->setDownloadSpeed(0);
   mirror->setStatus(ServerStat::A2_ERROR);
   mirror->setLastUpdated(Time(1210000002));
diff --git a/test/SessionSerializerTest.cc b/test/SessionSerializerTest.cc
index b47a461a..00442f68 100644
--- a/test/SessionSerializerTest.cc
+++ b/test/SessionSerializerTest.cc
@@ -42,17 +42,17 @@ void SessionSerializerTest::testSave()
       A2_TEST_DIR"/serialize_session.meta4",
       "magnet:?xt=urn:btih:248D0A1CD08284299DE78D5C1ED359BB46717D8C"};
   std::vector<std::string> uris(vbegin(URIs), vend(URIs));
-  std::vector<SharedHandle<RequestGroup> > result;
-  SharedHandle<Option> option(new Option());
+  std::vector<std::shared_ptr<RequestGroup> > result;
+  std::shared_ptr<Option> option(new Option());
   option->put(PREF_DIR, "/tmp");
   createRequestGroupForUri(result, option, uris);
   CPPUNIT_ASSERT_EQUAL((size_t)5, result.size());
   result[4]->getOption()->put(PREF_PAUSE, A2_V_TRUE);
   option->put(PREF_MAX_DOWNLOAD_RESULT, "10");
-  SharedHandle<RequestGroupMan> rgman
+  std::shared_ptr<RequestGroupMan> rgman
     (new RequestGroupMan(result, 1, option.get()));
   SessionSerializer s(rgman);
-  SharedHandle<DownloadResult> drs[] = {
+  std::shared_ptr<DownloadResult> drs[] = {
     // REMOVED downloads will not be saved.
     createDownloadResult(error_code::REMOVED, "http://removed"),
     createDownloadResult(error_code::TIME_OUT, "http://error"),
@@ -80,7 +80,7 @@ void SessionSerializerTest::testSave()
     rgman->addDownloadResult(drs[i]);
   }
 
-  DownloadEngine e(SharedHandle<EventPoll>(new SelectEventPoll()));
+  DownloadEngine e(std::shared_ptr<EventPoll>(new SelectEventPoll()));
   e.setOption(option.get());
   rgman->fillRequestGroupFromReserver(&e);
   CPPUNIT_ASSERT_EQUAL((size_t)1, rgman->getRequestGroups().size());
@@ -143,14 +143,14 @@ void SessionSerializerTest::testSave()
 
 void SessionSerializerTest::testSaveErrorDownload()
 {
-  SharedHandle<DownloadResult> dr = createDownloadResult(error_code::TIME_OUT,
+  std::shared_ptr<DownloadResult> dr = createDownloadResult(error_code::TIME_OUT,
                                                          "http://error");
   dr->fileEntries[0]->getSpentUris().swap
     (dr->fileEntries[0]->getRemainingUris());
-  SharedHandle<Option> option(new Option());
+  std::shared_ptr<Option> option(new Option());
   option->put(PREF_MAX_DOWNLOAD_RESULT, "10");
-  SharedHandle<RequestGroupMan> rgman
-    (new RequestGroupMan(std::vector<SharedHandle<RequestGroup> >(), 1,
+  std::shared_ptr<RequestGroupMan> rgman
+    (new RequestGroupMan(std::vector<std::shared_ptr<RequestGroup> >(), 1,
                          option.get()));
   rgman->addDownloadResult(dr);
   SessionSerializer s(rgman);
diff --git a/test/ShareRatioSeedCriteriaTest.cc b/test/ShareRatioSeedCriteriaTest.cc
index 03d1712b..45cbc9c9 100644
--- a/test/ShareRatioSeedCriteriaTest.cc
+++ b/test/ShareRatioSeedCriteriaTest.cc
@@ -23,11 +23,11 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION(ShareRatioSeedCriteriaTest);
 
 void ShareRatioSeedCriteriaTest::testEvaluate() {
-  SharedHandle<DownloadContext> dctx(new DownloadContext(1024*1024, 1000000));
-  SharedHandle<BtRuntime> btRuntime(new BtRuntime());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext(1024*1024, 1000000));
+  std::shared_ptr<BtRuntime> btRuntime(new BtRuntime());
   btRuntime->setUploadLengthAtStartup(1000000);
 
-  SharedHandle<MockPieceStorage> pieceStorage(new MockPieceStorage());
+  std::shared_ptr<MockPieceStorage> pieceStorage(new MockPieceStorage());
   pieceStorage->setCompletedLength(1000000);
 
   ShareRatioSeedCriteria cri(1.0, dctx);
diff --git a/test/SharedHandleTest.cc b/test/SharedHandleTest.cc
deleted file mode 100644
index 0e2bac60..00000000
--- a/test/SharedHandleTest.cc
+++ /dev/null
@@ -1,81 +0,0 @@
-#include "common.h"
-#include "SharedHandle.h"
-#include <string>
-#include <iostream>
-#include <cppunit/extensions/HelperMacros.h>
-
-namespace aria2 {
-
-class SharedHandleTest:public CppUnit::TestFixture {
-
-  CPPUNIT_TEST_SUITE(SharedHandleTest);
-  CPPUNIT_TEST(testSharedHandle);
-  CPPUNIT_TEST(testWeakHandle);
-  CPPUNIT_TEST_SUITE_END();
-
-  static SharedHandle<int> staticHandle;
-public:
-  void setUp() {
-  }
-
-  static SharedHandle<int> getInstance() {
-    if(!staticHandle) {
-      staticHandle.reset(new int(1));
-    }
-    return staticHandle;
-  }
-
-  void testSharedHandle();
-  void testWeakHandle();
-};
-
-SharedHandle<int> SharedHandleTest::staticHandle;
-
-CPPUNIT_TEST_SUITE_REGISTRATION( SharedHandleTest );
-
-void SharedHandleTest::testSharedHandle() {
-  std::cout << "xh:" << std::endl;
-  SharedHandle<int> xh(new int(1));
-
-  CPPUNIT_ASSERT_EQUAL((size_t)1, xh.getRefCount());
-
-  std::cout << "nullHandle:" << std::endl;
-  SharedHandle<int> nullHandle;
-
-  CPPUNIT_ASSERT_EQUAL((size_t)1, nullHandle.getRefCount());
-
-  std::cout << "staticHandle:" << std::endl;
-  CPPUNIT_ASSERT_EQUAL((size_t)1, staticHandle.getRefCount());
-
-  SharedHandle<int> localStaticHandle = getInstance();
-
-  CPPUNIT_ASSERT_EQUAL((size_t)2, localStaticHandle.getRefCount());
-}
-
-void SharedHandleTest::testWeakHandle()
-{
-  SharedHandle<int> x;
-  x.reset(new int(1));
-
-  WeakHandle<int> y = x;
-
-  WeakHandle<int> z;
-  z = y;
-
-  std::cout << "z.getRefCount() = " << z.getRefCount() << std::endl;
-  y.reset();
-  z.reset();
-
-  std::cout << "z.getRefCount() = " << z.getRefCount() << std::endl;
-
-  std::cout << "x.getRefCount() = " << x.getRefCount() << std::endl;
-
-  SharedHandle<int> w;
-
-  x = w;
-
-  std::cout << "w.getRefCount() = " << w.getRefCount() << std::endl;
-  std::cout << "x.getRefCount() = " << x.getRefCount() << std::endl;
-}
-
-} // namespace aria2
diff --git a/test/SingletonHolderTest.cc b/test/SingletonHolderTest.cc
index a3ac2eed..f9793616 100644
--- a/test/SingletonHolderTest.cc
+++ b/test/SingletonHolderTest.cc
@@ -4,8 +4,6 @@
 
 #include <cppunit/extensions/HelperMacros.h>
 
-#include "SharedHandle.h"
-
 namespace aria2 {
 
 class SingletonHolderTest : public CppUnit::TestFixture {
@@ -40,7 +38,7 @@ public:
 
 void SingletonHolderTest::testInstance()
 {
-  SharedHandle<M> m(new M("Hello world."));
+  std::shared_ptr<M> m(new M("Hello world."));
   SingletonHolder<M>::instance(m);
   CPPUNIT_ASSERT_EQUAL(std::string("Hello world."),
                        SingletonHolder<M>::instance()->greeting());
diff --git a/test/SinkStreamFilterTest.cc b/test/SinkStreamFilterTest.cc
index 1957d18a..c2d0adb4 100644
--- a/test/SinkStreamFilterTest.cc
+++ b/test/SinkStreamFilterTest.cc
@@ -41,9 +41,9 @@ class SinkStreamFilterTest:public CppUnit::TestFixture {
     int32_t writtenLength;
   };
 
-  SharedHandle<SinkStreamFilter> filter_;
-  SharedHandle<ByteArrayDiskWriter> writer_;
-  SharedHandle<MockSegment2> segment_;
+  std::shared_ptr<SinkStreamFilter> filter_;
+  std::shared_ptr<ByteArrayDiskWriter> writer_;
+  std::shared_ptr<MockSegment2> segment_;
 
   void clearWriter()
   {
diff --git a/test/TestUtil.cc b/test/TestUtil.cc
index ee8a685a..74d2800c 100644
--- a/test/TestUtil.cc
+++ b/test/TestUtil.cc
@@ -82,9 +82,9 @@ std::string fromHex(const std::string& s)
 
 #ifdef ENABLE_MESSAGE_DIGEST
 std::string fileHexDigest
-(const SharedHandle<MessageDigest>& ctx, const std::string& filename)
+(const std::shared_ptr<MessageDigest>& ctx, const std::string& filename)
 {
-  SharedHandle<DiskWriter> writer(new DefaultDiskWriter(filename));
+  std::shared_ptr<DiskWriter> writer(new DefaultDiskWriter(filename));
   writer->openExistingFile();
   return util::toHex(message_digest::digest(ctx, writer, 0, writer->size()));
 }
@@ -104,10 +104,10 @@ WrDiskCacheEntry::DataCell* createDataCell(int64_t goff,
   return cell;
 }
 
-SharedHandle<RequestGroup> findReservedGroup
-(const SharedHandle<RequestGroupMan>& rgman, a2_gid_t gid)
+std::shared_ptr<RequestGroup> findReservedGroup
+(const std::shared_ptr<RequestGroupMan>& rgman, a2_gid_t gid)
 {
-  SharedHandle<RequestGroup> rg = rgman->findGroup(gid);
+  std::shared_ptr<RequestGroup> rg = rgman->findGroup(gid);
   if(rg) {
     if(rg->getState() == RequestGroup::STATE_WAITING) {
       return rg;
@@ -118,8 +118,8 @@ SharedHandle<RequestGroup> findReservedGroup
   return rg;
 }
 
-SharedHandle<RequestGroup> getReservedGroup
-(const SharedHandle<RequestGroupMan>& rgman, size_t index)
+std::shared_ptr<RequestGroup> getReservedGroup
+(const std::shared_ptr<RequestGroupMan>& rgman, size_t index)
 {
   assert(rgman->getReservedGroups().size() > index);
   RequestGroupList::const_iterator i = rgman->getReservedGroups().begin();
@@ -127,38 +127,38 @@ SharedHandle<RequestGroup> getReservedGroup
   return *i;
 }
 
-SharedHandle<RequestGroup> createRequestGroup(int32_t pieceLength,
+std::shared_ptr<RequestGroup> createRequestGroup(int32_t pieceLength,
                                               int64_t totalLength,
                                               const std::string& path,
                                               const std::string& uri,
-                                              const SharedHandle<Option>& opt)
+                                              const std::shared_ptr<Option>& opt)
 {
-  SharedHandle<DownloadContext> dctx(new DownloadContext(pieceLength,
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext(pieceLength,
                                                          totalLength,
                                                          path));
   std::vector<std::string> uris;
   uris.push_back(uri);
   dctx->getFirstFileEntry()->addUris(uris.begin(), uris.end());
-  SharedHandle<RequestGroup> group(new RequestGroup(GroupId::create(), opt));
+  std::shared_ptr<RequestGroup> group(new RequestGroup(GroupId::create(), opt));
   group->setDownloadContext(dctx);
   return group;
 }
 
-SharedHandle<DownloadResult> createDownloadResult
+std::shared_ptr<DownloadResult> createDownloadResult
 (error_code::Value result, const std::string& uri)
 {
   std::vector<std::string> uris;
   uris.push_back(uri);
-  SharedHandle<FileEntry> entry(new FileEntry("/tmp/path", 1, 0, uris));
-  std::vector<SharedHandle<FileEntry> > entries;
+  std::shared_ptr<FileEntry> entry(new FileEntry("/tmp/path", 1, 0, uris));
+  std::vector<std::shared_ptr<FileEntry> > entries;
   entries.push_back(entry);
-  SharedHandle<DownloadResult> dr(new DownloadResult());
+  std::shared_ptr<DownloadResult> dr(new DownloadResult());
   dr->gid = GroupId::create();
   dr->fileEntries = entries;
   dr->result = result;
   dr->belongsTo = 0;
   dr->inMemoryDownload = false;
-  dr->option = SharedHandle<Option>(new Option());
+  dr->option = std::shared_ptr<Option>(new Option());
   return dr;
 }
 
diff --git a/test/TestUtil.h b/test/TestUtil.h
index 99894045..51bff38d 100644
--- a/test/TestUtil.h
+++ b/test/TestUtil.h
@@ -1,8 +1,8 @@
 #include "common.h"
 
 #include <string>
+#include <memory>
 
-#include "SharedHandle.h"
 #include "Cookie.h"
 #include "WrDiskCacheEntry.h"
 #include "GroupId.h"
@@ -53,26 +53,26 @@ std::string fromHex(const std::string& s);
 #ifdef ENABLE_MESSAGE_DIGEST
 // Returns hex digest of contents of file denoted by filename.
 std::string fileHexDigest
-(const SharedHandle<MessageDigest>& ctx, const std::string& filename);
+(const std::shared_ptr<MessageDigest>& ctx, const std::string& filename);
 #endif // ENABLE_MESSAGE_DIGEST
 
 WrDiskCacheEntry::DataCell* createDataCell(int64_t goff,
                                            const char* data,
                                            size_t offset = 0);
 
-SharedHandle<RequestGroup> findReservedGroup
-(const SharedHandle<RequestGroupMan>& rgman, a2_gid_t gid);
+std::shared_ptr<RequestGroup> findReservedGroup
+(const std::shared_ptr<RequestGroupMan>& rgman, a2_gid_t gid);
 
-SharedHandle<RequestGroup> getReservedGroup
-(const SharedHandle<RequestGroupMan>& rgman, size_t index);
+std::shared_ptr<RequestGroup> getReservedGroup
+(const std::shared_ptr<RequestGroupMan>& rgman, size_t index);
 
-SharedHandle<RequestGroup> createRequestGroup(int32_t pieceLength,
+std::shared_ptr<RequestGroup> createRequestGroup(int32_t pieceLength,
                                               int64_t totalLength,
                                               const std::string& path,
                                               const std::string& uri,
-                                              const SharedHandle<Option>& opt);
+                                              const std::shared_ptr<Option>& opt);
 
-SharedHandle<DownloadResult> createDownloadResult
+std::shared_ptr<DownloadResult> createDownloadResult
 (error_code::Value result, const std::string& uri);
 
 } // namespace aria2
diff --git a/test/UDPTrackerClientTest.cc b/test/UDPTrackerClientTest.cc
index 993dc750..80947571 100644
--- a/test/UDPTrackerClientTest.cc
+++ b/test/UDPTrackerClientTest.cc
@@ -35,11 +35,11 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION( UDPTrackerClientTest );
 
 namespace {
-SharedHandle<UDPTrackerRequest> createAnnounce(const std::string& remoteAddr,
+std::shared_ptr<UDPTrackerRequest> createAnnounce(const std::string& remoteAddr,
                                                uint16_t remotePort,
                                                int32_t transactionId)
 {
-  SharedHandle<UDPTrackerRequest> req(new UDPTrackerRequest());
+  std::shared_ptr<UDPTrackerRequest> req(new UDPTrackerRequest());
   req->connectionId = INT64_MAX;
   req->action = UDPT_ACT_ANNOUNCE;
   req->remoteAddr = remoteAddr;
@@ -104,7 +104,7 @@ void UDPTrackerClientTest::testCreateUDPTrackerConnect()
   unsigned char data[16];
   std::string remoteAddr;
   uint16_t remotePort = 0;
-  SharedHandle<UDPTrackerRequest> req(new UDPTrackerRequest());
+  std::shared_ptr<UDPTrackerRequest> req(new UDPTrackerRequest());
   req->action = UDPT_ACT_CONNECT;
   req->remoteAddr = "192.168.0.1";
   req->remotePort = 6991;
@@ -126,7 +126,7 @@ void UDPTrackerClientTest::testCreateUDPTrackerAnnounce()
   unsigned char data[100];
   std::string remoteAddr;
   uint16_t remotePort = 0;
-  SharedHandle<UDPTrackerRequest> req(createAnnounce("192.168.0.1", 6991,
+  std::shared_ptr<UDPTrackerRequest> req(createAnnounce("192.168.0.1", 6991,
                                                      1000000009));
   ssize_t rv = createUDPTrackerAnnounce(data, sizeof(data), remoteAddr,
                                         remotePort, req);
@@ -162,8 +162,8 @@ void UDPTrackerClientTest::testConnectFollowedByAnnounce()
   uint16_t remotePort;
   Timer now;
 
-  SharedHandle<UDPTrackerRequest> req1(createAnnounce("192.168.0.1", 6991, 0));
-  SharedHandle<UDPTrackerRequest> req2(createAnnounce("192.168.0.1", 6991, 0));
+  std::shared_ptr<UDPTrackerRequest> req1(createAnnounce("192.168.0.1", 6991, 0));
+  std::shared_ptr<UDPTrackerRequest> req2(createAnnounce("192.168.0.1", 6991, 0));
   req2->infohash = "bittorrent-infohash2";
 
   tr.addRequest(req1);
@@ -256,7 +256,7 @@ void UDPTrackerClientTest::testConnectFollowedByAnnounce()
 
   // Since we have connection ID, next announce request can be sent
   // immediately
-  SharedHandle<UDPTrackerRequest> req3(createAnnounce("192.168.0.1", 6991, 0));
+  std::shared_ptr<UDPTrackerRequest> req3(createAnnounce("192.168.0.1", 6991, 0));
   req3->infohash = "bittorrent-infohash3";
   tr.addRequest(req3);
   rv = tr.createRequest(data, sizeof(data), remoteAddr, remotePort, now);
@@ -266,7 +266,7 @@ void UDPTrackerClientTest::testConnectFollowedByAnnounce()
 
   tr.requestSent(now);
 
-  SharedHandle<UDPTrackerRequest> req4(createAnnounce("192.168.0.1", 6991, 0));
+  std::shared_ptr<UDPTrackerRequest> req4(createAnnounce("192.168.0.1", 6991, 0));
   req4->infohash = "bittorrent-infohash4";
   tr.addRequest(req4);
   Timer future = now;
@@ -288,9 +288,9 @@ void UDPTrackerClientTest::testRequestFailure()
   uint16_t remotePort;
   Timer now;
   {
-    SharedHandle<UDPTrackerRequest> req1
+    std::shared_ptr<UDPTrackerRequest> req1
       (createAnnounce("192.168.0.1", 6991, 0));
-    SharedHandle<UDPTrackerRequest> req2
+    std::shared_ptr<UDPTrackerRequest> req2
       (createAnnounce("192.168.0.1", 6991, 0));
 
     tr.addRequest(req1);
@@ -308,9 +308,9 @@ void UDPTrackerClientTest::testRequestFailure()
     CPPUNIT_ASSERT(tr.getInflightRequests().empty());
   }
   {
-    SharedHandle<UDPTrackerRequest> req1
+    std::shared_ptr<UDPTrackerRequest> req1
       (createAnnounce("192.168.0.1", 6991, 0));
-    SharedHandle<UDPTrackerRequest> req2
+    std::shared_ptr<UDPTrackerRequest> req2
       (createAnnounce("192.168.0.1", 6991, 0));
 
     tr.addRequest(req1);
@@ -332,7 +332,7 @@ void UDPTrackerClientTest::testRequestFailure()
     CPPUNIT_ASSERT(tr.getInflightRequests().empty());
   }
   {
-    SharedHandle<UDPTrackerRequest> req1
+    std::shared_ptr<UDPTrackerRequest> req1
       (createAnnounce("192.168.0.1", 6991, 0));
 
     tr.addRequest(req1);
@@ -373,9 +373,9 @@ void UDPTrackerClientTest::testTimeout()
   Timer now;
   UDPTrackerClient tr;
   {
-    SharedHandle<UDPTrackerRequest> req1
+    std::shared_ptr<UDPTrackerRequest> req1
       (createAnnounce("192.168.0.1", 6991, 0));
-    SharedHandle<UDPTrackerRequest> req2
+    std::shared_ptr<UDPTrackerRequest> req2
       (createAnnounce("192.168.0.1", 6991, 0));
 
     tr.addRequest(req1);
@@ -408,7 +408,7 @@ void UDPTrackerClientTest::testTimeout()
     CPPUNIT_ASSERT_EQUAL((int)UDPT_ERR_TIMEOUT, req2->error);
   }
   {
-    SharedHandle<UDPTrackerRequest> req1
+    std::shared_ptr<UDPTrackerRequest> req1
       (createAnnounce("192.168.0.1", 6991, 0));
 
     tr.addRequest(req1);
diff --git a/test/UTMetadataDataExtensionMessageTest.cc b/test/UTMetadataDataExtensionMessageTest.cc
index 6dcf9b85..58770cbf 100644
--- a/test/UTMetadataDataExtensionMessageTest.cc
+++ b/test/UTMetadataDataExtensionMessageTest.cc
@@ -65,15 +65,15 @@ void UTMetadataDataExtensionMessageTest::testToString()
 
 void UTMetadataDataExtensionMessageTest::testDoReceivedAction()
 {
-  SharedHandle<DirectDiskAdaptor> diskAdaptor(new DirectDiskAdaptor());
-  SharedHandle<ByteArrayDiskWriter> diskWriter(new ByteArrayDiskWriter());
+  std::shared_ptr<DirectDiskAdaptor> diskAdaptor(new DirectDiskAdaptor());
+  std::shared_ptr<ByteArrayDiskWriter> diskWriter(new ByteArrayDiskWriter());
   diskAdaptor->setDiskWriter(diskWriter);
-  SharedHandle<MockPieceStorage> pieceStorage(new MockPieceStorage());
+  std::shared_ptr<MockPieceStorage> pieceStorage(new MockPieceStorage());
   pieceStorage->setDiskAdaptor(diskAdaptor);
-  SharedHandle<UTMetadataRequestTracker> tracker
+  std::shared_ptr<UTMetadataRequestTracker> tracker
     (new UTMetadataRequestTracker());
-  SharedHandle<DownloadContext> dctx(new DownloadContext());
-  SharedHandle<TorrentAttribute> attrs(new TorrentAttribute());
+  std::shared_ptr<DownloadContext> dctx(new DownloadContext());
+  std::shared_ptr<TorrentAttribute> attrs(new TorrentAttribute());
 
   std::string piece0 = std::string(METADATA_PIECE_SIZE, '0');
   std::string piece1 = std::string(METADATA_PIECE_SIZE, '1');
diff --git a/test/UTMetadataPostDownloadHandlerTest.cc b/test/UTMetadataPostDownloadHandlerTest.cc
index 23966aa5..e98ce000 100644
--- a/test/UTMetadataPostDownloadHandlerTest.cc
+++ b/test/UTMetadataPostDownloadHandlerTest.cc
@@ -26,9 +26,9 @@ class UTMetadataPostDownloadHandlerTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testGetNextRequestGroups);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<Option> option_;
-  SharedHandle<DownloadContext> dctx_;
-  SharedHandle<RequestGroup> requestGroup_;
+  std::shared_ptr<Option> option_;
+  std::shared_ptr<DownloadContext> dctx_;
+  std::shared_ptr<RequestGroup> requestGroup_;
 public:
   void setUp()
   {
@@ -52,7 +52,7 @@ void UTMetadataPostDownloadHandlerTest::testCanHandle()
 
   CPPUNIT_ASSERT(!handler.canHandle(requestGroup_.get()));
 
-  SharedHandle<TorrentAttribute> attrs(new TorrentAttribute());
+  std::shared_ptr<TorrentAttribute> attrs(new TorrentAttribute());
   dctx_->setAttribute(CTX_ATTR_BT, attrs);
 
   CPPUNIT_ASSERT(handler.canHandle(requestGroup_.get()));
@@ -77,7 +77,7 @@ void UTMetadataPostDownloadHandlerTest::testGetNextRequestGroups()
     (infoHash, sizeof(infoHash), MessageDigest::sha1(),
      reinterpret_cast<const unsigned char*>(metadata.data()), metadata.size());
   dctx_->getFirstFileEntry()->setLength(metadata.size());
-  SharedHandle<TorrentAttribute> attrs(new TorrentAttribute());
+  std::shared_ptr<TorrentAttribute> attrs(new TorrentAttribute());
   attrs->infoHash = std::string(&infoHash[0], &infoHash[20]);
   std::vector<std::vector<std::string> > announceList;
   std::vector<std::string> announceTier;
@@ -86,20 +86,20 @@ void UTMetadataPostDownloadHandlerTest::testGetNextRequestGroups()
   attrs->announceList = announceList;
   dctx_->setAttribute(CTX_ATTR_BT, attrs);
   requestGroup_->setDiskWriterFactory
-    (SharedHandle<DiskWriterFactory>(new ByteArrayDiskWriterFactory()));
+    (std::shared_ptr<DiskWriterFactory>(new ByteArrayDiskWriterFactory()));
   requestGroup_->initPieceStorage();
   requestGroup_->getPieceStorage()->getDiskAdaptor()->writeData
     (reinterpret_cast<const unsigned char*>(metadata.data()), metadata.size(),
      0);
 
   UTMetadataPostDownloadHandler handler;
-  std::vector<SharedHandle<RequestGroup> > results;
+  std::vector<std::shared_ptr<RequestGroup> > results;
   handler.getNextRequestGroups(results, requestGroup_.get());
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, results.size());
-  SharedHandle<RequestGroup> newRg = results.front();
-  SharedHandle<DownloadContext> newDctx = newRg->getDownloadContext();
-  SharedHandle<TorrentAttribute> newAttrs =
+  std::shared_ptr<RequestGroup> newRg = results.front();
+  std::shared_ptr<DownloadContext> newDctx = newRg->getDownloadContext();
+  std::shared_ptr<TorrentAttribute> newAttrs =
     bittorrent::getTorrentAttrs(newDctx);
   CPPUNIT_ASSERT_EQUAL(bittorrent::getInfoHashString(dctx_),
                        bittorrent::getInfoHashString(newDctx));
diff --git a/test/UTMetadataRequestExtensionMessageTest.cc b/test/UTMetadataRequestExtensionMessageTest.cc
index 226209d7..97ba5a2f 100644
--- a/test/UTMetadataRequestExtensionMessageTest.cc
+++ b/test/UTMetadataRequestExtensionMessageTest.cc
@@ -31,17 +31,17 @@ class UTMetadataRequestExtensionMessageTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testDoReceivedAction_data);
   CPPUNIT_TEST_SUITE_END();
 public:
-  SharedHandle<DownloadContext> dctx_;
-  SharedHandle<WrapExtBtMessageFactory> messageFactory_;
-  SharedHandle<MockBtMessageDispatcher> dispatcher_;
-  SharedHandle<Peer> peer_;
+  std::shared_ptr<DownloadContext> dctx_;
+  std::shared_ptr<WrapExtBtMessageFactory> messageFactory_;
+  std::shared_ptr<MockBtMessageDispatcher> dispatcher_;
+  std::shared_ptr<Peer> peer_;
 
   void setUp()
   {
     messageFactory_.reset(new WrapExtBtMessageFactory());
     dispatcher_.reset(new MockBtMessageDispatcher());
     dctx_.reset(new DownloadContext());
-    SharedHandle<TorrentAttribute> attrs(new TorrentAttribute());
+    std::shared_ptr<TorrentAttribute> attrs(new TorrentAttribute());
     dctx_->setAttribute(CTX_ATTR_BT, attrs);
     peer_.reset(new Peer("host", 6880));
     peer_->allocateSessionResource(0, 0);
@@ -49,14 +49,12 @@ public:
   }
 
   template<typename T>
-  SharedHandle<T> getFirstDispatchedMessage()
+  std::shared_ptr<T> getFirstDispatchedMessage()
   {
-    SharedHandle<WrapExtBtMessage> wrapmsg =
-      dynamic_pointer_cast<WrapExtBtMessage>
+    auto wrapmsg = std::dynamic_pointer_cast<WrapExtBtMessage>
       (dispatcher_->messageQueue.front());
 
-    SharedHandle<T> msg = dynamic_pointer_cast<T>(wrapmsg->m_);
-    return msg;
+    return std::dynamic_pointer_cast<T>(wrapmsg->m_);
   }
 
   void testGetExtensionMessageID();
@@ -109,7 +107,7 @@ void UTMetadataRequestExtensionMessageTest::testDoReceivedAction_reject()
   msg.setBtMessageDispatcher(dispatcher_.get());
   msg.doReceivedAction();
 
-  SharedHandle<UTMetadataRejectExtensionMessage> m =
+  std::shared_ptr<UTMetadataRejectExtensionMessage> m =
     getFirstDispatchedMessage<UTMetadataRejectExtensionMessage>();
 
   CPPUNIT_ASSERT(m);
@@ -127,7 +125,7 @@ void UTMetadataRequestExtensionMessageTest::testDoReceivedAction_data()
   msg.setBtMessageDispatcher(dispatcher_.get());
 
   size_t metadataSize = METADATA_PIECE_SIZE*2;
-  SharedHandle<TorrentAttribute> attrs = bittorrent::getTorrentAttrs(dctx_);
+  std::shared_ptr<TorrentAttribute> attrs = bittorrent::getTorrentAttrs(dctx_);
   std::string first(METADATA_PIECE_SIZE, '0');
   std::string second(METADATA_PIECE_SIZE, '1');
   attrs->metadata = first+second;
@@ -135,7 +133,7 @@ void UTMetadataRequestExtensionMessageTest::testDoReceivedAction_data()
 
   msg.doReceivedAction();
 
-  SharedHandle<UTMetadataDataExtensionMessage> m =
+  std::shared_ptr<UTMetadataDataExtensionMessage> m =
     getFirstDispatchedMessage<UTMetadataDataExtensionMessage>();
 
   CPPUNIT_ASSERT(m);
diff --git a/test/UTMetadataRequestFactoryTest.cc b/test/UTMetadataRequestFactoryTest.cc
index bfa37c62..d5b3654d 100644
--- a/test/UTMetadataRequestFactoryTest.cc
+++ b/test/UTMetadataRequestFactoryTest.cc
@@ -28,17 +28,17 @@ public:
   public:
     std::deque<size_t> missingIndexes;
 
-    virtual SharedHandle<Piece> getMissingPiece
-    (const SharedHandle<Peer>& peer,
+    virtual std::shared_ptr<Piece> getMissingPiece
+    (const std::shared_ptr<Peer>& peer,
      const std::vector<size_t>& exlucdedIndexes,
      cuid_t cuid)
     {
       if(missingIndexes.empty()) {
-        return SharedHandle<Piece>();
+        return std::shared_ptr<Piece>();
       } else {
         size_t index = missingIndexes.front();
         missingIndexes.pop_front();
-        return SharedHandle<Piece>(new Piece(index, 0));
+        return std::shared_ptr<Piece>(new Piece(index, 0));
       }
     }
   };
@@ -50,23 +50,23 @@ CPPUNIT_TEST_SUITE_REGISTRATION(UTMetadataRequestFactoryTest);
 void UTMetadataRequestFactoryTest::testCreate()
 {
   UTMetadataRequestFactory factory;
-  SharedHandle<DownloadContext> dctx
+  std::shared_ptr<DownloadContext> dctx
     (new DownloadContext(METADATA_PIECE_SIZE, METADATA_PIECE_SIZE*2));
   factory.setDownloadContext(dctx);
-  SharedHandle<MockPieceStorage2> ps(new MockPieceStorage2());
+  std::shared_ptr<MockPieceStorage2> ps(new MockPieceStorage2());
   ps->missingIndexes.push_back(0);
   ps->missingIndexes.push_back(1);
-  SharedHandle<WrapExtBtMessageFactory> messageFactory
+  std::shared_ptr<WrapExtBtMessageFactory> messageFactory
     (new WrapExtBtMessageFactory());
   factory.setBtMessageFactory(messageFactory.get());
-  SharedHandle<Peer> peer(new Peer("peer", 6880));
+  std::shared_ptr<Peer> peer(new Peer("peer", 6880));
   peer->allocateSessionResource(0, 0);
   factory.setPeer(peer);
-  SharedHandle<UTMetadataRequestTracker> tracker
+  std::shared_ptr<UTMetadataRequestTracker> tracker
     (new UTMetadataRequestTracker());
   factory.setUTMetadataRequestTracker(tracker.get());
 
-  std::vector<SharedHandle<BtMessage> > msgs;
+  std::vector<std::shared_ptr<BtMessage> > msgs;
 
   factory.create(msgs, 1, ps);
   CPPUNIT_ASSERT_EQUAL((size_t)1, msgs.size());
diff --git a/test/UTPexExtensionMessageTest.cc b/test/UTPexExtensionMessageTest.cc
index e9589c71..c153e687 100644
--- a/test/UTPexExtensionMessageTest.cc
+++ b/test/UTPexExtensionMessageTest.cc
@@ -31,7 +31,7 @@ class UTPexExtensionMessageTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testDroppedPeersAreFull);
   CPPUNIT_TEST_SUITE_END();
 private:
-  SharedHandle<MockPeerStorage> peerStorage_;
+  std::shared_ptr<MockPeerStorage> peerStorage_;
 public:
   void setUp()
   {
@@ -70,23 +70,23 @@ void UTPexExtensionMessageTest::testGetExtensionName()
 void UTPexExtensionMessageTest::testGetBencodedData()
 {
   UTPexExtensionMessage msg(1);
-  SharedHandle<Peer> p1(new Peer("192.168.0.1", 6881));
+  std::shared_ptr<Peer> p1(new Peer("192.168.0.1", 6881));
   p1->allocateSessionResource(256*1024, 1024*1024);
   p1->setAllBitfield();
   CPPUNIT_ASSERT(msg.addFreshPeer(p1));// added seeder, check add.f flag
-  SharedHandle<Peer> p2(new Peer("10.1.1.2", 9999));
+  std::shared_ptr<Peer> p2(new Peer("10.1.1.2", 9999));
   CPPUNIT_ASSERT(msg.addFreshPeer(p2));
-  SharedHandle<Peer> p3(new Peer("192.168.0.2", 6882));
+  std::shared_ptr<Peer> p3(new Peer("192.168.0.2", 6882));
   p3->startDrop();
   CPPUNIT_ASSERT(msg.addDroppedPeer(p3));
-  SharedHandle<Peer> p4(new Peer("10.1.1.3", 10000));
+  std::shared_ptr<Peer> p4(new Peer("10.1.1.3", 10000));
   p4->startDrop();
   CPPUNIT_ASSERT(msg.addDroppedPeer(p4));
 
-  SharedHandle<Peer> p5(new Peer("1002:1035:4527:3546:7854:1237:3247:3217",
+  std::shared_ptr<Peer> p5(new Peer("1002:1035:4527:3546:7854:1237:3247:3217",
                                  6881));
   CPPUNIT_ASSERT(msg.addFreshPeer(p5));
-  SharedHandle<Peer> p6(new Peer("2001:db8:bd05:1d2:288a:1fc0:1:10ee", 6882));
+  std::shared_ptr<Peer> p6(new Peer("2001:db8:bd05:1d2:288a:1fc0:1:10ee", 6882));
   p6->startDrop();
   CPPUNIT_ASSERT(msg.addDroppedPeer(p6));
 
@@ -119,16 +119,16 @@ void UTPexExtensionMessageTest::testGetBencodedData()
 void UTPexExtensionMessageTest::testToString()
 {
   UTPexExtensionMessage msg(1);
-  SharedHandle<Peer> p1(new Peer("192.168.0.1", 6881));
+  std::shared_ptr<Peer> p1(new Peer("192.168.0.1", 6881));
   p1->allocateSessionResource(256*1024, 1024*1024);
   p1->setAllBitfield();
   msg.addFreshPeer(p1);// added seeder, check add.f flag
-  SharedHandle<Peer> p2(new Peer("10.1.1.2", 9999));
+  std::shared_ptr<Peer> p2(new Peer("10.1.1.2", 9999));
   msg.addFreshPeer(p2);
-  SharedHandle<Peer> p3(new Peer("192.168.0.2", 6882));
+  std::shared_ptr<Peer> p3(new Peer("192.168.0.2", 6882));
   p3->startDrop();
   msg.addDroppedPeer(p3);
-  SharedHandle<Peer> p4(new Peer("10.1.1.3", 10000));
+  std::shared_ptr<Peer> p4(new Peer("10.1.1.3", 10000));
   p4->startDrop();
   msg.addDroppedPeer(p4);
   CPPUNIT_ASSERT_EQUAL(std::string("ut_pex added=2, dropped=2"), msg.toString());
@@ -137,17 +137,17 @@ void UTPexExtensionMessageTest::testToString()
 void UTPexExtensionMessageTest::testDoReceivedAction()
 {
   UTPexExtensionMessage msg(1);
-  SharedHandle<Peer> p1(new Peer("192.168.0.1", 6881));
+  std::shared_ptr<Peer> p1(new Peer("192.168.0.1", 6881));
   p1->allocateSessionResource(256*1024, 1024*1024);
   p1->setAllBitfield();
   msg.addFreshPeer(p1);// added seeder, check add.f flag
-  SharedHandle<Peer> p2(new Peer("1002:1035:4527:3546:7854:1237:3247:3217",
+  std::shared_ptr<Peer> p2(new Peer("1002:1035:4527:3546:7854:1237:3247:3217",
                                  9999));
   msg.addFreshPeer(p2);
-  SharedHandle<Peer> p3(new Peer("192.168.0.2", 6882));
+  std::shared_ptr<Peer> p3(new Peer("192.168.0.2", 6882));
   p3->startDrop();
   msg.addDroppedPeer(p3);
-  SharedHandle<Peer> p4(new Peer("2001:db8:bd05:1d2:288a:1fc0:1:10ee", 10000));
+  std::shared_ptr<Peer> p4(new Peer("2001:db8:bd05:1d2:288a:1fc0:1:10ee", 10000));
   p4->startDrop();
   msg.addDroppedPeer(p4);
   msg.setPeerStorage(peerStorage_);
@@ -156,22 +156,22 @@ void UTPexExtensionMessageTest::testDoReceivedAction()
 
   CPPUNIT_ASSERT_EQUAL((size_t)4, peerStorage_->getUnusedPeers().size());
   {
-    SharedHandle<Peer> p = peerStorage_->getUnusedPeers()[0];
+    std::shared_ptr<Peer> p = peerStorage_->getUnusedPeers()[0];
     CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), p->getIPAddress());
     CPPUNIT_ASSERT_EQUAL((uint16_t)6881, p->getPort());
   }
   {
-    SharedHandle<Peer> p = peerStorage_->getUnusedPeers()[1];
+    std::shared_ptr<Peer> p = peerStorage_->getUnusedPeers()[1];
     CPPUNIT_ASSERT_EQUAL(std::string("1002:1035:4527:3546:7854:1237:3247:3217"),
                          p->getIPAddress());
     CPPUNIT_ASSERT_EQUAL((uint16_t)9999, p->getPort());
   }
   {
-    SharedHandle<Peer> p = peerStorage_->getUnusedPeers()[2];
+    std::shared_ptr<Peer> p = peerStorage_->getUnusedPeers()[2];
     CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.2"), p->getIPAddress());
   }
   {
-    SharedHandle<Peer> p = peerStorage_->getUnusedPeers()[3];
+    std::shared_ptr<Peer> p = peerStorage_->getUnusedPeers()[3];
     CPPUNIT_ASSERT_EQUAL(std::string("2001:db8:bd05:1d2:288a:1fc0:1:10ee"),
                          p->getIPAddress());
   }
@@ -203,7 +203,7 @@ void UTPexExtensionMessageTest::testCreate()
     "8:dropped618:"+std::string(&c6[0], &c6[COMPACT_LEN_IPV6])+
     "e";
 
-  SharedHandle<UTPexExtensionMessage> msg
+  std::shared_ptr<UTPexExtensionMessage> msg
     (UTPexExtensionMessage::create
      (reinterpret_cast<const unsigned char*>(data.c_str()), data.size()));
   CPPUNIT_ASSERT_EQUAL((uint8_t)1, msg->getExtensionMessageID());
@@ -244,24 +244,24 @@ void UTPexExtensionMessageTest::testCreate()
 void UTPexExtensionMessageTest::testAddFreshPeer()
 {
   UTPexExtensionMessage msg(1);
-  SharedHandle<Peer> p1(new Peer("192.168.0.1", 6881));
+  std::shared_ptr<Peer> p1(new Peer("192.168.0.1", 6881));
   CPPUNIT_ASSERT(msg.addFreshPeer(p1));
-  SharedHandle<Peer> p2(new Peer("10.1.1.2", 9999));
+  std::shared_ptr<Peer> p2(new Peer("10.1.1.2", 9999));
   p2->setFirstContactTime(Timer(Timer().getTime()-61));
   CPPUNIT_ASSERT(!msg.addFreshPeer(p2));
-  SharedHandle<Peer> p3(new Peer("10.1.1.3", 9999, true));
+  std::shared_ptr<Peer> p3(new Peer("10.1.1.3", 9999, true));
   CPPUNIT_ASSERT(!msg.addFreshPeer(p3));
 }
 
 void UTPexExtensionMessageTest::testAddDroppedPeer()
 {
   UTPexExtensionMessage msg(1);
-  SharedHandle<Peer> p1(new Peer("192.168.0.1", 6881));
+  std::shared_ptr<Peer> p1(new Peer("192.168.0.1", 6881));
   CPPUNIT_ASSERT(!msg.addDroppedPeer(p1));
-  SharedHandle<Peer> p2(new Peer("10.1.1.2", 9999));
+  std::shared_ptr<Peer> p2(new Peer("10.1.1.2", 9999));
   p2->startDrop();
   CPPUNIT_ASSERT(msg.addFreshPeer(p2));
-  SharedHandle<Peer> p3(new Peer("10.1.1.3", 9999, true));
+  std::shared_ptr<Peer> p3(new Peer("10.1.1.3", 9999, true));
   p3->startDrop();
   CPPUNIT_ASSERT(!msg.addDroppedPeer(p3));
 }
@@ -271,13 +271,13 @@ void UTPexExtensionMessageTest::testFreshPeersAreFull()
   UTPexExtensionMessage msg(1);
   CPPUNIT_ASSERT_EQUAL((size_t)50, msg.getMaxFreshPeer());
   msg.setMaxFreshPeer(2);
-  SharedHandle<Peer> p1(new Peer("192.168.0.1", 6881));
+  std::shared_ptr<Peer> p1(new Peer("192.168.0.1", 6881));
   CPPUNIT_ASSERT(msg.addFreshPeer(p1));
   CPPUNIT_ASSERT(!msg.freshPeersAreFull());
-  SharedHandle<Peer> p2(new Peer("10.1.1.2", 9999));
+  std::shared_ptr<Peer> p2(new Peer("10.1.1.2", 9999));
   CPPUNIT_ASSERT(msg.addFreshPeer(p2));
   CPPUNIT_ASSERT(msg.freshPeersAreFull());
-  SharedHandle<Peer> p3(new Peer("10.1.1.3", 9999));
+  std::shared_ptr<Peer> p3(new Peer("10.1.1.3", 9999));
   CPPUNIT_ASSERT(msg.addFreshPeer(p3));
   CPPUNIT_ASSERT(msg.freshPeersAreFull());
 }
@@ -287,15 +287,15 @@ void UTPexExtensionMessageTest::testDroppedPeersAreFull()
   UTPexExtensionMessage msg(1);
   CPPUNIT_ASSERT_EQUAL((size_t)50, msg.getMaxDroppedPeer());
   msg.setMaxDroppedPeer(2);
-  SharedHandle<Peer> p1(new Peer("192.168.0.1", 6881));
+  std::shared_ptr<Peer> p1(new Peer("192.168.0.1", 6881));
   p1->startDrop();
   CPPUNIT_ASSERT(msg.addDroppedPeer(p1));
   CPPUNIT_ASSERT(!msg.droppedPeersAreFull());
-  SharedHandle<Peer> p2(new Peer("10.1.1.2", 9999));
+  std::shared_ptr<Peer> p2(new Peer("10.1.1.2", 9999));
   p2->startDrop();
   CPPUNIT_ASSERT(msg.addDroppedPeer(p2));
   CPPUNIT_ASSERT(msg.droppedPeersAreFull());
-  SharedHandle<Peer> p3(new Peer("10.1.1.3", 9999));
+  std::shared_ptr<Peer> p3(new Peer("10.1.1.3", 9999));
   p3->startDrop();
   CPPUNIT_ASSERT(msg.addDroppedPeer(p3));
   CPPUNIT_ASSERT(msg.droppedPeersAreFull());
diff --git a/test/UtilTest.cc b/test/UtilTest.cc
index 77f15184..4af99529 100644
--- a/test/UtilTest.cc
+++ b/test/UtilTest.cc
@@ -1566,9 +1566,9 @@ void UtilTest::testAbbrevSize()
 void UtilTest::testToStream()
 {
   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;
+  std::shared_ptr<FileEntry> f1(new FileEntry("aria2.tar.bz2", 12300, 0));
+  std::shared_ptr<FileEntry> f2(new FileEntry("aria2.txt", 556, 0));
+  std::deque<std::shared_ptr<FileEntry> > entries;
   entries.push_back(f1);
   entries.push_back(f2);
   const char* filename = A2_TEST_OUT_DIR"/aria2_UtilTest_testToStream";
@@ -1791,7 +1791,7 @@ void UtilTest::testParseLLIntNoThrow()
 
 void UtilTest::testToString_binaryStream()
 {
-  SharedHandle<DiskWriter> dw(new ByteArrayDiskWriter());
+  std::shared_ptr<DiskWriter> dw(new ByteArrayDiskWriter());
   std::string data(16*1024+256, 'a');
   dw->initAndOpenFile();
   dw->writeData((const unsigned char*)data.c_str(), data.size(), 0);
@@ -1987,7 +1987,7 @@ void UtilTest::testParsePrioritizePieceRange()
   //                      |                    |
   //                      file4                |
   size_t pieceLength = 1024;
-  std::vector<SharedHandle<FileEntry> > entries(4, SharedHandle<FileEntry>());
+  std::vector<std::shared_ptr<FileEntry> > entries(4, std::shared_ptr<FileEntry>());
   entries[0].reset(new FileEntry("file1", 1024, 0));
   entries[1].reset(new FileEntry("file2",2560,entries[0]->getLastOffset()));
   entries[2].reset(new FileEntry("file3",0,entries[1]->getLastOffset()));
diff --git a/test/ValueBaseBencodeParserTest.cc b/test/ValueBaseBencodeParserTest.cc
index 677f1dce..bc67b233 100644
--- a/test/ValueBaseBencodeParserTest.cc
+++ b/test/ValueBaseBencodeParserTest.cc
@@ -22,7 +22,7 @@ void checkDecodeError(const std::string& src)
 {
   bittorrent::ValueBaseBencodeParser parser;
   ssize_t error;
-  SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+  std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                 error);
   CPPUNIT_ASSERT(!r);
   CPPUNIT_ASSERT(error < 0);
@@ -36,42 +36,42 @@ void ValueBaseBencodeParserTest::testParseUpdate()
   {
     // empty string
     std::string src = "0:";
-    SharedHandle<ValueBase> s = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> s = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     CPPUNIT_ASSERT_EQUAL(std::string(""), downcast<String>(s)->s());
   }
   {
     // integer 0
     std::string src = "i0e";
-    SharedHandle<ValueBase> s = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> s = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     CPPUNIT_ASSERT_EQUAL((int64_t)0, downcast<Integer>(s)->i());
   }
   {
     // empty dict
     std::string src = "de";
-    SharedHandle<ValueBase> d = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> d = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     CPPUNIT_ASSERT(downcast<Dict>(d)->empty());
   }
   {
     // empty list
     std::string src = "le";
-    SharedHandle<ValueBase> l = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> l = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     CPPUNIT_ASSERT(downcast<List>(l)->empty());
   }
   {
     // string
     std::string src = "3:foo";
-    SharedHandle<ValueBase> s = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> s = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     CPPUNIT_ASSERT_EQUAL(std::string("foo"), downcast<String>(s)->s());
   }
   {
     // integer
     std::string src = "i9223372036854775807e";
-    SharedHandle<ValueBase> s = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> s = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775807LL,
                          downcast<Integer>(s)->i());
@@ -79,7 +79,7 @@ void ValueBaseBencodeParserTest::testParseUpdate()
   {
     // dict, size 1
     std::string src = "d3:fooi123ee";
-    SharedHandle<ValueBase> d = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> d = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     Dict* dict = downcast<Dict>(d);
     CPPUNIT_ASSERT(dict);
@@ -90,7 +90,7 @@ void ValueBaseBencodeParserTest::testParseUpdate()
   {
     // dict, size 2
     std::string src = "d3:fooi123e3:bar1:ee";
-    SharedHandle<ValueBase> d = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> d = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     Dict* dict = downcast<Dict>(d);
     CPPUNIT_ASSERT(dict);
@@ -105,7 +105,7 @@ void ValueBaseBencodeParserTest::testParseUpdate()
   {
     // list, size 1
     std::string src = "l3:fooe";
-    SharedHandle<ValueBase> l = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> l = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     List* list = downcast<List>(l);
     CPPUNIT_ASSERT(list);
@@ -116,7 +116,7 @@ void ValueBaseBencodeParserTest::testParseUpdate()
   {
     // list, size 2
     std::string src = "l3:fooi123ee";
-    SharedHandle<ValueBase> l = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> l = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     List* list = downcast<List>(l);
     CPPUNIT_ASSERT(list);
@@ -129,7 +129,7 @@ void ValueBaseBencodeParserTest::testParseUpdate()
   {
     // string, integer and list in dict
     std::string src = "d4:name5:aria24:sizei12345678900e5:filesl3:bin3:docee";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const Dict* dict = downcast<Dict>(r);
     CPPUNIT_ASSERT(dict);
@@ -148,7 +148,7 @@ void ValueBaseBencodeParserTest::testParseUpdate()
   {
     // dict in list
     std::string src = "ld1:ki123eee";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -161,13 +161,13 @@ void ValueBaseBencodeParserTest::testParseUpdate()
   {
     // empty key is allowed
     std::string src = "d0:1:ve";
-    SharedHandle<ValueBase> s = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> s = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
   }
   {
     // empty encoded data
     std::string src = "";
-    SharedHandle<ValueBase> s = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> s = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     CPPUNIT_ASSERT(!s);
   }
@@ -189,7 +189,7 @@ void ValueBaseBencodeParserTest::testParseUpdate()
   {
     // ignore trailing garbage at the end of the input.
     std::string src = "5:aria2trail";
-    SharedHandle<ValueBase> s = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> s = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     CPPUNIT_ASSERT_EQUAL(std::string("aria2"), downcast<String>(s)->s());
     // Get trailing garbage position
diff --git a/test/ValueBaseJsonParserTest.cc b/test/ValueBaseJsonParserTest.cc
index 546206d8..9e35b0de 100644
--- a/test/ValueBaseJsonParserTest.cc
+++ b/test/ValueBaseJsonParserTest.cc
@@ -30,7 +30,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // empty object
     std::string src = "{}";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const Dict* dict = downcast<Dict>(r);
     CPPUNIT_ASSERT(dict);
@@ -38,7 +38,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // empty object
     std::string src = "{  }";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const Dict* dict = downcast<Dict>(r);
     CPPUNIT_ASSERT(dict);
@@ -46,7 +46,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // empty array
     std::string src = "[]";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -54,7 +54,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // empty array
     std::string src = "[ ]";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -62,7 +62,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // empty string
     std::string src = "[\"\"]";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -72,7 +72,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // string
     std::string src = "[\"foobar\"]";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -82,7 +82,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // string with escape
     std::string src = "[\"\\\\foo\\\"\\\"bar\"]";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -92,7 +92,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // string with escape
     std::string src = "[\"foo\\\"\"]";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -102,7 +102,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // string: utf-8 1 to 3 bytes.
     std::string src = "[\"\\u0024\\u00A2\\u20AC\"]";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -112,7 +112,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // string: utf-8 4 bytes
     std::string src = "[\"\\uD852\\uDF62\"]";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -123,7 +123,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // null
     std::string src = "[null]";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -133,7 +133,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // true, false
     std::string src = "[true, false]";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -147,7 +147,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // object: 1 member
     std::string src = "{\"foo\":[\"bar\"]}";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const Dict* dict = downcast<Dict>(r);
     CPPUNIT_ASSERT(dict);
@@ -160,7 +160,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
     // object: 2 members
     // TODO ValueBaseJsonParser does not allow empty dict key
     std::string src = "{\"foo\":[\"bar\"], \"alpha\" : \"bravo\"}";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const Dict* dict = downcast<Dict>(r);
     CPPUNIT_ASSERT(dict);
@@ -174,7 +174,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // array: 2 values
     std::string src = "[\"foo\", {}]";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -186,7 +186,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // Number: currently we ignore frac and exp
     std::string src = "[0,-1,1.2,-1.2e-10,-1e10]";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -204,7 +204,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // escape chars: ", \, /, \b, \f, \n, \r, \t
     std::string src = "[\"\\\"\\\\\\/\\b\\f\\n\\r\\t\"]";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     const String* s = downcast<String>(list->get(0));
@@ -213,7 +213,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // string: literal + escaped chars.
     std::string src = "[\"foo\\u0024b\\u00A2\\u20ACbaz\"]";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -223,7 +223,7 @@ void ValueBaseJsonParserTest::testParseUpdate()
   {
     // ignore garbage at the end of the input.
     std::string src = "[]trail";
-    SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+    std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                   error);
     const List* list = downcast<List>(r);
     CPPUNIT_ASSERT(list);
@@ -236,7 +236,7 @@ void checkDecodeError(const std::string& src)
 {
   json::ValueBaseJsonParser parser;
   ssize_t error;
-  SharedHandle<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
+  std::shared_ptr<ValueBase> r = parser.parseFinal(src.c_str(), src.size(),
                                                 error);
   CPPUNIT_ASSERT(!r);
   CPPUNIT_ASSERT(error < 0);
diff --git a/test/ValueBaseTest.cc b/test/ValueBaseTest.cc
index cf4727a2..6edeb02b 100644
--- a/test/ValueBaseTest.cc
+++ b/test/ValueBaseTest.cc
@@ -65,7 +65,7 @@ void ValueBaseTest::testDowncast()
   CPPUNIT_ASSERT(x);
   CPPUNIT_ASSERT_EQUAL(static_cast<Integer::ValueType>(100), x->i());
   CPPUNIT_ASSERT(!downcast<String>(&integer));
-  SharedHandle<Integer> si(new Integer(101));
+  std::shared_ptr<Integer> si(new Integer(101));
   const Integer* x2 = downcast<Integer>(si);
   CPPUNIT_ASSERT_EQUAL(static_cast<Integer::ValueType>(101), x2->i());
 
diff --git a/test/WrDiskCacheEntryTest.cc b/test/WrDiskCacheEntryTest.cc
index 71779a5a..996cee62 100644
--- a/test/WrDiskCacheEntryTest.cc
+++ b/test/WrDiskCacheEntryTest.cc
@@ -18,8 +18,8 @@ class WrDiskCacheEntryTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testClear);
   CPPUNIT_TEST_SUITE_END();
 
-  SharedHandle<DirectDiskAdaptor> adaptor_;
-  SharedHandle<ByteArrayDiskWriter> writer_;
+  std::shared_ptr<DirectDiskAdaptor> adaptor_;
+  std::shared_ptr<ByteArrayDiskWriter> writer_;
 public:
   void setUp()
   {
diff --git a/test/WrDiskCacheTest.cc b/test/WrDiskCacheTest.cc
index 6e0663a7..b668ee91 100644
--- a/test/WrDiskCacheTest.cc
+++ b/test/WrDiskCacheTest.cc
@@ -16,8 +16,8 @@ class WrDiskCacheTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testAdd);
   CPPUNIT_TEST_SUITE_END();
 
-  SharedHandle<DirectDiskAdaptor> adaptor_;
-  SharedHandle<ByteArrayDiskWriter> writer_;
+  std::shared_ptr<DirectDiskAdaptor> adaptor_;
+  std::shared_ptr<ByteArrayDiskWriter> writer_;
 public:
   void setUp()
   {
diff --git a/test/a2functionalTest.cc b/test/a2functionalTest.cc
index 8e803b41..85e12404 100644
--- a/test/a2functionalTest.cc
+++ b/test/a2functionalTest.cc
@@ -31,7 +31,7 @@ public:
     virtual std::string sayGreetingConst() const = 0;
   };
 
-  typedef SharedHandle<Greeting> GreetingHandle;
+  typedef std::shared_ptr<Greeting> GreetingHandle;
 
   class JapaneseGreeting:public Greeting
   {
diff --git a/test/extension_message_test_helper.h b/test/extension_message_test_helper.h
index dfc9ac3f..5cef2241 100644
--- a/test/extension_message_test_helper.h
+++ b/test/extension_message_test_helper.h
@@ -10,10 +10,10 @@ typedef WrapBtMessage<ExtensionMessage> WrapExtBtMessage;
 
 class WrapExtBtMessageFactory:public MockBtMessageFactory {
 public:
-  virtual SharedHandle<BtMessage>
-  createBtExtendedMessage(const SharedHandle<ExtensionMessage>& extmsg)
+  virtual std::shared_ptr<BtMessage>
+  createBtExtendedMessage(const std::shared_ptr<ExtensionMessage>& extmsg)
   {
-    return SharedHandle<BtMessage>(new WrapExtBtMessage(extmsg));
+    return std::shared_ptr<BtMessage>(new WrapExtBtMessage(extmsg));
   }
 };