kudu-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From danburk...@apache.org
Subject [5/9] incubator-kudu git commit: Enable C++11
Date Wed, 13 Jan 2016 17:18:20 GMT
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/mini_cluster.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/mini_cluster.cc b/src/kudu/integration-tests/mini_cluster.cc
index 279d979..ccc1377 100644
--- a/src/kudu/integration-tests/mini_cluster.cc
+++ b/src/kudu/integration-tests/mini_cluster.cc
@@ -22,9 +22,9 @@
 #include "kudu/client/client.h"
 #include "kudu/gutil/strings/join.h"
 #include "kudu/gutil/strings/substitute.h"
-#include "kudu/master/mini_master.h"
 #include "kudu/master/catalog_manager.h"
 #include "kudu/master/master.h"
+#include "kudu/master/mini_master.h"
 #include "kudu/master/ts_descriptor.h"
 #include "kudu/master/ts_manager.h"
 #include "kudu/rpc/messenger.h"
@@ -42,9 +42,9 @@ namespace kudu {
 using client::KuduClient;
 using client::KuduClientBuilder;
 using master::MiniMaster;
-using master::TSDescriptor;
 using master::TabletLocationsPB;
-using std::tr1::shared_ptr;
+using master::TSDescriptor;
+using std::shared_ptr;
 using tserver::MiniTabletServer;
 using tserver::TabletServer;
 
@@ -303,7 +303,7 @@ Status MiniCluster::WaitForTabletServerCount(int count,
 }
 
 Status MiniCluster::CreateClient(KuduClientBuilder* builder,
-                                 shared_ptr<KuduClient>* client) {
+                                 client::sp::shared_ptr<KuduClient>* client) {
   KuduClientBuilder default_builder;
   if (builder == NULL) {
     builder = &default_builder;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/mini_cluster.h
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/mini_cluster.h b/src/kudu/integration-tests/mini_cluster.h
index 89b55a8..43ee3d8 100644
--- a/src/kudu/integration-tests/mini_cluster.h
+++ b/src/kudu/integration-tests/mini_cluster.h
@@ -18,10 +18,11 @@
 #ifndef KUDU_INTEGRATION_TESTS_MINI_CLUSTER_H
 #define KUDU_INTEGRATION_TESTS_MINI_CLUSTER_H
 
+#include <memory>
 #include <string>
-#include <tr1/memory>
 #include <vector>
 
+#include "kudu/client/shared_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/util/env.h"
 
@@ -149,7 +150,7 @@ class MiniCluster {
   // within kRegistrationWaitTimeSeconds.
   Status WaitForTabletServerCount(int count);
   Status WaitForTabletServerCount(int count,
-                                  std::vector<std::tr1::shared_ptr<master::TSDescriptor> >* descs);
+                                  std::vector<std::shared_ptr<master::TSDescriptor> >* descs);
 
   // Create a client configured to talk to this cluster. Builder may contain
   // override options for the client. The master address will be overridden to
@@ -158,7 +159,7 @@ class MiniCluster {
   //
   // REQUIRES: the cluster must have already been Start()ed.
   Status CreateClient(client::KuduClientBuilder* builder,
-                      std::tr1::shared_ptr<client::KuduClient>* client);
+                      client::sp::shared_ptr<client::KuduClient>* client);
 
  private:
   enum {
@@ -177,8 +178,8 @@ class MiniCluster {
   const std::vector<uint16_t> master_rpc_ports_;
   const std::vector<uint16_t> tserver_rpc_ports_;
 
-  std::vector<std::tr1::shared_ptr<master::MiniMaster> > mini_masters_;
-  std::vector<std::tr1::shared_ptr<tserver::MiniTabletServer> > mini_tablet_servers_;
+  std::vector<std::shared_ptr<master::MiniMaster> > mini_masters_;
+  std::vector<std::shared_ptr<tserver::MiniTabletServer> > mini_tablet_servers_;
 };
 
 } // namespace kudu

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/raft_consensus-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/raft_consensus-itest.cc b/src/kudu/integration-tests/raft_consensus-itest.cc
index c6bed73..b8351c0 100644
--- a/src/kudu/integration-tests/raft_consensus-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus-itest.cc
@@ -16,20 +16,19 @@
 // under the License.
 
 #include <boost/foreach.hpp>
-#include <boost/assign/list_of.hpp>
 #include <boost/optional.hpp>
 #include <gflags/gflags.h>
-#include <gtest/gtest.h>
 #include <glog/logging.h>
 #include <glog/stl_logging.h>
-#include <tr1/unordered_map>
-#include <tr1/unordered_set>
+#include <gtest/gtest.h>
+#include <unordered_map>
+#include <unordered_set>
 
-#include "kudu/client/client.h"
 #include "kudu/client/client-test-util.h"
+#include "kudu/client/client.h"
 #include "kudu/client/write_op.h"
-#include "kudu/common/wire_protocol-test-util.h"
 #include "kudu/common/schema.h"
+#include "kudu/common/wire_protocol-test-util.h"
 #include "kudu/common/wire_protocol.h"
 #include "kudu/consensus/consensus.pb.h"
 #include "kudu/consensus/consensus_peers.h"
@@ -60,17 +59,17 @@ METRIC_DECLARE_gauge_int64(raft_term);
 namespace kudu {
 namespace tserver {
 
-using boost::assign::list_of;
-using consensus::ConsensusResponsePB;
+using client::KuduInsert;
+using client::KuduSession;
+using client::KuduTable;
+using client::sp::shared_ptr;
 using consensus::ConsensusRequestPB;
+using consensus::ConsensusResponsePB;
 using consensus::ConsensusServiceProxy;
 using consensus::MajoritySize;
 using consensus::MakeOpId;
 using consensus::RaftPeerPB;
 using consensus::ReplicateMsg;
-using client::KuduInsert;
-using client::KuduSession;
-using client::KuduTable;
 using itest::AddServer;
 using itest::GetReplicaStatusAndCheckIfLeader;
 using itest::LeaderStepDown;
@@ -84,10 +83,9 @@ using master::TabletLocationsPB;
 using rpc::RpcController;
 using server::SetFlagRequestPB;
 using server::SetFlagResponsePB;
+using std::unordered_map;
+using std::unordered_set;
 using std::vector;
-using std::tr1::shared_ptr;
-using std::tr1::unordered_map;
-using std::tr1::unordered_set;
 using strings::Substitute;
 
 static const int kConsensusRpcTimeoutForTests = 50;
@@ -427,7 +425,7 @@ TEST_F(RaftConsensusITest, TestGetPermanentUuid) {
 
   rpc::MessengerBuilder builder("test builder");
   builder.set_num_reactors(1);
-  shared_ptr<rpc::Messenger> messenger;
+  std::shared_ptr<rpc::Messenger> messenger;
   ASSERT_OK(builder.Build(&messenger));
 
   ASSERT_OK(consensus::SetPermanentUuidForRemotePeer(messenger, &peer));
@@ -706,7 +704,7 @@ void RaftConsensusITest::CauseFollowerToFallBehindLogGC(string* leader_uuid,
   LOG(INFO) << "Waiting for log GC on " << leader->uuid();
   // Some WAL segments must exist, but wal segment 1 must not exist.
   ASSERT_OK(inspect_->WaitForFilePatternInTabletWalDirOnTs(
-      leader_index, tablet_id_, list_of("wal-"), list_of("wal-000000001")));
+      leader_index, tablet_id_, { "wal-" }, { "wal-000000001" }));
 
   LOG(INFO) << "Log GC complete on " << leader->uuid();
 
@@ -753,7 +751,7 @@ void RaftConsensusITest::CauseFollowerToFallBehindLogGC(string* leader_uuid,
 // This is a regression test for KUDU-775 and KUDU-562.
 TEST_F(RaftConsensusITest, TestFollowerFallsBehindLeaderGC) {
   // Disable follower eviction to maintain the original intent of this test.
-  vector<string> extra_flags = list_of("--evict_failed_followers=false");
+  vector<string> extra_flags = { "--evict_failed_followers=false" };
   AddFlagsForLogRolls(&extra_flags); // For CauseFollowerToFallBehindLogGC().
   BuildAndStart(extra_flags);
 
@@ -1069,7 +1067,7 @@ TEST_F(RaftConsensusITest, TestAutomaticLeaderElectionOneReplica) {
   FLAGS_num_tablet_servers = 1;
   FLAGS_num_replicas = 1;
   vector<string> ts_flags;
-  vector<string> master_flags = list_of("--catalog_manager_allow_local_consensus=false");
+  vector<string> master_flags = { "--catalog_manager_allow_local_consensus=false" };
   BuildAndStart(ts_flags, master_flags);
 
   TServerDetails* leader;
@@ -1529,8 +1527,8 @@ void RaftConsensusITest::WaitForReplicasReportedToMaster(
 TEST_F(RaftConsensusITest, TestAddRemoveServer) {
   FLAGS_num_tablet_servers = 3;
   FLAGS_num_replicas = 3;
-  vector<string> ts_flags = list_of("--enable_leader_failure_detection=false");
-  vector<string> master_flags = list_of("--master_add_server_when_underreplicated=false");
+  vector<string> ts_flags = { "--enable_leader_failure_detection=false" };
+  vector<string> master_flags = { "--master_add_server_when_underreplicated=false" };
   master_flags.push_back("--catalog_manager_wait_for_new_tablets_to_elect_leader=false");
   NO_FATALS(BuildAndStart(ts_flags, master_flags));
 
@@ -1567,7 +1565,7 @@ TEST_F(RaftConsensusITest, TestAddRemoveServer) {
   int64_t cur_log_index = opid.index();
 
   // Go from 3 tablet servers down to 1 in the configuration.
-  vector<int> remove_list = list_of(2)(1);
+  vector<int> remove_list = { 2, 1 };
   BOOST_FOREACH(int to_remove_idx, remove_list) {
     int num_servers = active_tablet_servers.size();
     LOG(INFO) << "Remove: Going from " << num_servers << " to " << num_servers - 1 << " replicas";
@@ -1587,7 +1585,7 @@ TEST_F(RaftConsensusITest, TestAddRemoveServer) {
   }
 
   // Add the tablet servers back, in reverse order, going from 1 to 3 servers in the configuration.
-  vector<int> add_list = list_of(1)(2);
+  vector<int> add_list = { 1, 2 };
   BOOST_FOREACH(int to_add_idx, add_list) {
     int num_servers = active_tablet_servers.size();
     LOG(INFO) << "Add: Going from " << num_servers << " to " << num_servers + 1 << " replicas";
@@ -1612,8 +1610,8 @@ TEST_F(RaftConsensusITest, TestAddRemoveServer) {
 TEST_F(RaftConsensusITest, TestReplaceChangeConfigOperation) {
   FLAGS_num_tablet_servers = 3;
   FLAGS_num_replicas = 3;
-  vector<string> ts_flags = list_of("--enable_leader_failure_detection=false");
-  vector<string> master_flags = list_of("--master_add_server_when_underreplicated=false");
+  vector<string> ts_flags = { "--enable_leader_failure_detection=false" };
+  vector<string> master_flags = { "--master_add_server_when_underreplicated=false" };
   master_flags.push_back("--catalog_manager_wait_for_new_tablets_to_elect_leader=false");
   NO_FATALS(BuildAndStart(ts_flags, master_flags));
 
@@ -1668,8 +1666,8 @@ TEST_F(RaftConsensusITest, TestReplaceChangeConfigOperation) {
 TEST_F(RaftConsensusITest, TestAtomicAddRemoveServer) {
   FLAGS_num_tablet_servers = 3;
   FLAGS_num_replicas = 3;
-  vector<string> ts_flags = list_of("--enable_leader_failure_detection=false");
-  vector<string> master_flags = list_of("--master_add_server_when_underreplicated=false");
+  vector<string> ts_flags = { "--enable_leader_failure_detection=false" };
+  vector<string> master_flags = { "--master_add_server_when_underreplicated=false" };
   master_flags.push_back("--catalog_manager_wait_for_new_tablets_to_elect_leader=false");
   NO_FATALS(BuildAndStart(ts_flags, master_flags));
 
@@ -1863,8 +1861,8 @@ void DoWriteTestRows(const TServerDetails* leader_tserver,
 TEST_F(RaftConsensusITest, TestConfigChangeUnderLoad) {
   FLAGS_num_tablet_servers = 3;
   FLAGS_num_replicas = 3;
-  vector<string> ts_flags = list_of("--enable_leader_failure_detection=false");
-  vector<string> master_flags = list_of("--master_add_server_when_underreplicated=false");
+  vector<string> ts_flags = { "--enable_leader_failure_detection=false" };
+  vector<string> master_flags = { "--master_add_server_when_underreplicated=false" };
   master_flags.push_back("--catalog_manager_wait_for_new_tablets_to_elect_leader=false");
   BuildAndStart(ts_flags, master_flags);
 
@@ -1897,7 +1895,7 @@ TEST_F(RaftConsensusITest, TestConfigChangeUnderLoad) {
 
   LOG(INFO) << "Removing servers...";
   // Go from 3 tablet servers down to 1 in the configuration.
-  vector<int> remove_list = list_of(2)(1);
+  vector<int> remove_list = { 2, 1 };
   BOOST_FOREACH(int to_remove_idx, remove_list) {
     int num_servers = active_tablet_servers.size();
     LOG(INFO) << "Remove: Going from " << num_servers << " to " << num_servers - 1 << " replicas";
@@ -1914,7 +1912,7 @@ TEST_F(RaftConsensusITest, TestConfigChangeUnderLoad) {
 
   LOG(INFO) << "Adding servers...";
   // Add the tablet servers back, in reverse order, going from 1 to 3 servers in the configuration.
-  vector<int> add_list = list_of(1)(2);
+  vector<int> add_list = { 1, 2 };
   BOOST_FOREACH(int to_add_idx, add_list) {
     int num_servers = active_tablet_servers.size();
     LOG(INFO) << "Add: Going from " << num_servers << " to " << num_servers + 1 << " replicas";
@@ -1954,7 +1952,7 @@ TEST_F(RaftConsensusITest, TestMasterNotifiedOnConfigChange) {
   FLAGS_num_tablet_servers = 3;
   FLAGS_num_replicas = 2;
   vector<string> ts_flags;
-  vector<string> master_flags = list_of("--master_add_server_when_underreplicated=false");
+  vector<string> master_flags = { "--master_add_server_when_underreplicated=false" };
   NO_FATALS(BuildAndStart(ts_flags, master_flags));
 
   LOG(INFO) << "Finding tablet leader and waiting for things to start...";
@@ -2335,7 +2333,7 @@ TEST_F(RaftConsensusITest, TestHammerOneRow) {
 TEST_F(RaftConsensusITest, TestEvictAbandonedFollowers) {
   vector<string> ts_flags;
   AddFlagsForLogRolls(&ts_flags); // For CauseFollowerToFallBehindLogGC().
-  vector<string> master_flags = list_of("--master_add_server_when_underreplicated=false");
+  vector<string> master_flags = { "--master_add_server_when_underreplicated=false" };
   NO_FATALS(BuildAndStart(ts_flags, master_flags));
 
   MonoDelta timeout = MonoDelta::FromSeconds(30);
@@ -2382,9 +2380,8 @@ TEST_F(RaftConsensusITest, TestMasterReplacesEvictedFollowers) {
 // This is required for correctness of Raft config change. For details,
 // see https://groups.google.com/forum/#!topic/raft-dev/t4xj6dJTP6E
 TEST_F(RaftConsensusITest, TestChangeConfigRejectedUnlessNoopReplicated) {
-  vector<string> ts_flags = list_of("--enable_leader_failure_detection=false");
-  vector<string> master_flags = list_of(
-      "--catalog_manager_wait_for_new_tablets_to_elect_leader=false");
+  vector<string> ts_flags = { "--enable_leader_failure_detection=false" };
+  vector<string> master_flags = { "--catalog_manager_wait_for_new_tablets_to_elect_leader=false" };
   BuildAndStart(ts_flags, master_flags);
 
   MonoDelta timeout = MonoDelta::FromSeconds(30);

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/registration-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/registration-test.cc b/src/kudu/integration-tests/registration-test.cc
index f7cd358..0895990 100644
--- a/src/kudu/integration-tests/registration-test.cc
+++ b/src/kudu/integration-tests/registration-test.cc
@@ -15,11 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
+#include <memory>
 #include <string>
-#include <tr1/memory>
 
 #include "kudu/common/schema.h"
 #include "kudu/common/wire_protocol-test-util.h"
@@ -43,7 +42,7 @@ DECLARE_int32(heartbeat_interval_ms);
 namespace kudu {
 
 using std::vector;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using master::MiniMaster;
 using master::TSDescriptor;
 using master::TabletLocationsPB;
@@ -54,9 +53,7 @@ using tserver::MiniTabletServer;
 class RegistrationTest : public KuduTest {
  public:
   RegistrationTest()
-    : schema_(boost::assign::list_of
-              (ColumnSchema("c1", UINT32)),
-              1) {
+    : schema_({ ColumnSchema("c1", UINT32) }, 1) {
   }
 
   virtual void SetUp() OVERRIDE {

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/remote_bootstrap-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/remote_bootstrap-itest.cc b/src/kudu/integration-tests/remote_bootstrap-itest.cc
index f033bac..3a72353 100644
--- a/src/kudu/integration-tests/remote_bootstrap-itest.cc
+++ b/src/kudu/integration-tests/remote_bootstrap-itest.cc
@@ -18,12 +18,11 @@
 #include <boost/optional.hpp>
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
-#include <tr1/memory>
-#include <tr1/unordered_map>
 #include <string>
+#include <unordered_map>
 
-#include "kudu/client/client.h"
 #include "kudu/client/client-test-util.h"
+#include "kudu/client/client.h"
 #include "kudu/common/wire_protocol-test-util.h"
 #include "kudu/fs/fs_manager.h"
 #include "kudu/gutil/stl_util.h"
@@ -54,14 +53,14 @@ using kudu::client::KuduClientBuilder;
 using kudu::client::KuduSchema;
 using kudu::client::KuduSchemaFromSchema;
 using kudu::client::KuduTableCreator;
+using kudu::client::sp::shared_ptr;
 using kudu::consensus::CONSENSUS_CONFIG_COMMITTED;
 using kudu::itest::TServerDetails;
 using kudu::tablet::TABLET_DATA_TOMBSTONED;
 using kudu::tserver::ListTabletsResponsePB;
 using kudu::tserver::RemoteBootstrapClient;
 using std::string;
-using std::tr1::shared_ptr;
-using std::tr1::unordered_map;
+using std::unordered_map;
 using std::vector;
 using strings::Substitute;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/tablet_replacement-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/tablet_replacement-itest.cc b/src/kudu/integration-tests/tablet_replacement-itest.cc
index e6db434..4cab317 100644
--- a/src/kudu/integration-tests/tablet_replacement-itest.cc
+++ b/src/kudu/integration-tests/tablet_replacement-itest.cc
@@ -15,13 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
 #include <boost/optional.hpp>
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
+#include <memory>
 #include <string>
-#include <tr1/memory>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 #include "kudu/common/wire_protocol.h"
 #include "kudu/common/wire_protocol-test-util.h"
@@ -30,15 +29,14 @@
 #include "kudu/integration-tests/cluster_verifier.h"
 #include "kudu/integration-tests/test_workload.h"
 
-using boost::assign::list_of;
 using kudu::consensus::RaftPeerPB;
 using kudu::itest::TServerDetails;
 using kudu::tablet::TABLET_DATA_READY;
 using kudu::tablet::TABLET_DATA_TOMBSTONED;
 using kudu::tserver::ListTabletsResponsePB;
+using std::shared_ptr;
 using std::string;
-using std::tr1::shared_ptr;
-using std::tr1::unordered_map;
+using std::unordered_map;
 using std::vector;
 using strings::Substitute;
 
@@ -52,9 +50,9 @@ class TabletReplacementITest : public ExternalMiniClusterITestBase {
 // not part of the committed config yet (only the pending config).
 TEST_F(TabletReplacementITest, TestMasterTombstoneEvictedReplica) {
   MonoDelta timeout = MonoDelta::FromSeconds(30);
-  vector<string> ts_flags = list_of("--enable_leader_failure_detection=false");
+  vector<string> ts_flags = { "--enable_leader_failure_detection=false" };
   int num_tservers = 5;
-  vector<string> master_flags = list_of("--master_add_server_when_underreplicated=false");
+  vector<string> master_flags = { "--master_add_server_when_underreplicated=false" };
   master_flags.push_back("--catalog_manager_wait_for_new_tablets_to_elect_leader=false");
   NO_FATALS(StartCluster(ts_flags, master_flags, num_tservers));
 
@@ -122,8 +120,8 @@ TEST_F(TabletReplacementITest, TestMasterTombstoneEvictedReplica) {
 // than TestMasterTombstoneEvictedReplica does.
 TEST_F(TabletReplacementITest, TestMasterTombstoneOldReplicaOnReport) {
   MonoDelta timeout = MonoDelta::FromSeconds(30);
-  vector<string> ts_flags = list_of("--enable_leader_failure_detection=false");
-  vector<string> master_flags = list_of("--master_add_server_when_underreplicated=false");
+  vector<string> ts_flags = { "--enable_leader_failure_detection=false" };
+  vector<string> master_flags = { "--master_add_server_when_underreplicated=false" };
   master_flags.push_back("--catalog_manager_wait_for_new_tablets_to_elect_leader=false");
   NO_FATALS(StartCluster(ts_flags, master_flags));
 
@@ -180,10 +178,9 @@ TEST_F(TabletReplacementITest, TestEvictAndReplaceDeadFollower) {
   }
 
   MonoDelta timeout = MonoDelta::FromSeconds(30);
-  vector<string> ts_flags = list_of("--enable_leader_failure_detection=false")
-                                   ("--follower_unavailable_considered_failed_sec=5");
-  vector<string> master_flags = list_of(
-      "--catalog_manager_wait_for_new_tablets_to_elect_leader=false");
+  vector<string> ts_flags = { "--enable_leader_failure_detection=false",
+                              "--follower_unavailable_considered_failed_sec=5" };
+  vector<string> master_flags = { "--catalog_manager_wait_for_new_tablets_to_elect_leader=false" };
   NO_FATALS(StartCluster(ts_flags, master_flags));
 
   TestWorkload workload(cluster_.get());

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/test_workload.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/test_workload.cc b/src/kudu/integration-tests/test_workload.cc
index 57d47b6..aa6ab25 100644
--- a/src/kudu/integration-tests/test_workload.cc
+++ b/src/kudu/integration-tests/test_workload.cc
@@ -47,7 +47,7 @@ using client::KuduSession;
 using client::KuduTable;
 using client::KuduTableCreator;
 using client::KuduUpdate;
-using std::tr1::shared_ptr;
+using client::sp::shared_ptr;
 
 const char* const TestWorkload::kDefaultTableName = "test-workload";
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/test_workload.h
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/test_workload.h b/src/kudu/integration-tests/test_workload.h
index f704bc7..4d106ed 100644
--- a/src/kudu/integration-tests/test_workload.h
+++ b/src/kudu/integration-tests/test_workload.h
@@ -128,7 +128,7 @@ class TestWorkload {
 
   ExternalMiniCluster* cluster_;
   client::KuduClientBuilder client_builder_;
-  std::tr1::shared_ptr<client::KuduClient> client_;
+  client::sp::shared_ptr<client::KuduClient> client_;
 
   int payload_bytes_;
   int num_write_threads_;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/ts_itest-base.h
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/ts_itest-base.h b/src/kudu/integration-tests/ts_itest-base.h
index 1e91951..17d29c0 100644
--- a/src/kudu/integration-tests/ts_itest-base.h
+++ b/src/kudu/integration-tests/ts_itest-base.h
@@ -20,13 +20,12 @@
 #include <boost/foreach.hpp>
 #include <glog/stl_logging.h>
 #include <string>
-#include <tr1/memory>
 #include <utility>
 #include <vector>
 
 #include "kudu/client/client-test-util.h"
-#include "kudu/consensus/quorum_util.h"
 #include "kudu/client/schema-internal.h"
+#include "kudu/consensus/quorum_util.h"
 #include "kudu/gutil/strings/split.h"
 #include "kudu/integration-tests/cluster_itest_util.h"
 #include "kudu/integration-tests/cluster_verifier.h"
@@ -139,7 +138,7 @@ class TabletServerIntegrationTestBase : public TabletServerTestBase {
 
     bool replicas_missing = true;
     do {
-      std::tr1::unordered_multimap<std::string, TServerDetails*> tablet_replicas;
+      std::unordered_multimap<std::string, TServerDetails*> tablet_replicas;
       GetTableLocationsRequestPB req;
       GetTableLocationsResponsePB resp;
       RpcController controller;
@@ -400,7 +399,7 @@ class TabletServerIntegrationTestBase : public TabletServerTestBase {
     STLDeleteValues(&tablet_servers_);
   }
 
-  void CreateClient(std::tr1::shared_ptr<client::KuduClient>* client) {
+  void CreateClient(client::sp::shared_ptr<client::KuduClient>* client) {
     // Connect to the cluster.
     ASSERT_OK(client::KuduClientBuilder()
                      .add_master_server_addr(cluster_->master()->bound_rpc_addr().ToString())
@@ -452,8 +451,8 @@ class TabletServerIntegrationTestBase : public TabletServerTestBase {
   // Maps tablet to all replicas.
   TabletReplicaMap tablet_replicas_;
 
-  std::tr1::shared_ptr<client::KuduClient> client_;
-  std::tr1::shared_ptr<client::KuduTable> table_;
+  client::sp::shared_ptr<client::KuduClient> client_;
+  client::sp::shared_ptr<client::KuduTable> table_;
   std::string tablet_id_;
 
   ThreadSafeRandom random_;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/ts_recovery-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/ts_recovery-itest.cc b/src/kudu/integration-tests/ts_recovery-itest.cc
index a9fa8b0..6818dc9 100644
--- a/src/kudu/integration-tests/ts_recovery-itest.cc
+++ b/src/kudu/integration-tests/ts_recovery-itest.cc
@@ -20,10 +20,8 @@
 #include "kudu/integration-tests/test_workload.h"
 #include "kudu/util/test_util.h"
 
-#include <boost/assign/list_of.hpp>
 #include <string>
 
-using boost::assign::list_of;
 using std::string;
 
 namespace kudu {
@@ -94,7 +92,7 @@ TEST_F(TsRecoveryITest, TestRestartWithOrphanedReplicates) {
 
 // Test that we replay from the recovery directory, if it exists.
 TEST_F(TsRecoveryITest, TestCrashDuringLogReplay) {
-  NO_FATALS(StartCluster(list_of("--fault_crash_during_log_replay=0.05")));
+  NO_FATALS(StartCluster({ "--fault_crash_during_log_replay=0.05" }));
 
   TestWorkload work(cluster_.get());
   work.set_num_replicas(1);

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/ts_tablet_manager-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/ts_tablet_manager-itest.cc b/src/kudu/integration-tests/ts_tablet_manager-itest.cc
index 0910621..e792f5d 100644
--- a/src/kudu/integration-tests/ts_tablet_manager-itest.cc
+++ b/src/kudu/integration-tests/ts_tablet_manager-itest.cc
@@ -16,8 +16,8 @@
 // under the License.
 
 #include <gtest/gtest.h>
+#include <memory>
 #include <string>
-#include <tr1/memory>
 
 #include "kudu/client/client.h"
 #include "kudu/consensus/consensus.proxy.h"
@@ -62,7 +62,6 @@ using master::ReportedTabletPB;
 using master::TabletReportPB;
 using rpc::Messenger;
 using rpc::MessengerBuilder;
-using std::tr1::shared_ptr;
 using strings::Substitute;
 using tablet::TabletPeer;
 using tserver::MiniTabletServer;
@@ -83,8 +82,8 @@ class TsTabletManagerITest : public KuduTest {
   const KuduSchema schema_;
 
   gscoped_ptr<MiniCluster> cluster_;
-  shared_ptr<KuduClient> client_;
-  shared_ptr<Messenger> client_messenger_;
+  client::sp::shared_ptr<KuduClient> client_;
+  std::shared_ptr<Messenger> client_messenger_;
 };
 
 void TsTabletManagerITest::SetUp() {
@@ -117,7 +116,7 @@ TEST_F(TsTabletManagerITest, TestReportNewLeaderOnLeaderChange) {
   OverrideFlagForSlowTests("num_election_test_loops", "10");
 
   // Create the table.
-  shared_ptr<KuduTable> table;
+  client::sp::shared_ptr<KuduTable> table;
   gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
   ASSERT_OK(table_creator->table_name(kTableName)
             .schema(&schema_)

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/update_scan_delta_compact-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/update_scan_delta_compact-test.cc b/src/kudu/integration-tests/update_scan_delta_compact-test.cc
index 21ebd04..aa51e3f 100644
--- a/src/kudu/integration-tests/update_scan_delta_compact-test.cc
+++ b/src/kudu/integration-tests/update_scan_delta_compact-test.cc
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -42,9 +42,6 @@ DEFINE_int32(row_count, 2000, "How many rows will be used in this test for the b
 DEFINE_int32(seconds_to_run, 4,
              "How long this test runs for, after inserting the base data, in seconds");
 
-using boost::assign::list_of;
-using std::tr1::shared_ptr;
-
 namespace kudu {
 namespace tablet {
 
@@ -62,6 +59,7 @@ using client::KuduStatusMemberCallback;
 using client::KuduTable;
 using client::KuduTableCreator;
 using client::KuduUpdate;
+using client::sp::shared_ptr;
 
 // This integration test tries to trigger all the update-related bits while also serving as a
 // foundation for benchmarking. It first inserts 'row_count' rows and then starts two threads,
@@ -150,7 +148,7 @@ class UpdateScanDeltaCompactionTest : public KuduTest {
                                   shared_ptr<KuduSession> session);
 
   KuduSchema schema_;
-  shared_ptr<MiniCluster> cluster_;
+  std::shared_ptr<MiniCluster> cluster_;
   shared_ptr<KuduTable> table_;
   shared_ptr<KuduClient> client_;
 };

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/catalog_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/catalog_manager.cc b/src/kudu/master/catalog_manager.cc
index 2259490..342580f 100644
--- a/src/kudu/master/catalog_manager.cc
+++ b/src/kudu/master/catalog_manager.cc
@@ -36,7 +36,6 @@
 
 #include "kudu/master/catalog_manager.h"
 
-#include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 #include <boost/optional.hpp>
 #include <boost/thread/condition_variable.hpp>
@@ -145,8 +144,8 @@ DEFINE_bool(catalog_manager_check_ts_count_for_create_table, true,
             "a table to be created.");
 TAG_FLAG(catalog_manager_check_ts_count_for_create_table, hidden);
 
+using std::shared_ptr;
 using std::string;
-using std::tr1::shared_ptr;
 using std::vector;
 
 namespace kudu {
@@ -1584,7 +1583,7 @@ Status CatalogManager::HandleReportedTablet(TSDescriptor* ts_desc,
   table_lock.Unlock();
   // We update the tablets each time that someone reports it.
   // This shouldn't be very frequent and should only happen when something in fact changed.
-  Status s = sys_catalog_->UpdateTablets(boost::assign::list_of(tablet.get()));
+  Status s = sys_catalog_->UpdateTablets({ tablet.get() });
   if (!s.ok()) {
     LOG(WARNING) << "Error updating tablets: " << s.ToString() << ". Tablet report was: "
                  << report.ShortDebugString();
@@ -2433,7 +2432,7 @@ void CatalogManager::DeleteTabletsAndSendRequests(const scoped_refptr<TableInfo>
 
     TabletMetadataLock tablet_lock(tablet.get(), TabletMetadataLock::WRITE);
     tablet_lock.mutable_data()->set_state(SysTabletsEntryPB::DELETED, deletion_msg);
-    CHECK_OK(sys_catalog_->UpdateTablets(boost::assign::list_of(tablet.get())));
+    CHECK_OK(sys_catalog_->UpdateTablets({ tablet.get() }));
     tablet_lock.Commit();
   }
 }

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/catalog_manager.h
----------------------------------------------------------------------
diff --git a/src/kudu/master/catalog_manager.h b/src/kudu/master/catalog_manager.h
index 5072960..11c4b9f 100644
--- a/src/kudu/master/catalog_manager.h
+++ b/src/kudu/master/catalog_manager.h
@@ -17,12 +17,12 @@
 #ifndef KUDU_MASTER_CATALOG_MANAGER_H
 #define KUDU_MASTER_CATALOG_MANAGER_H
 
-#include <boost/thread/mutex.hpp>
 #include <boost/optional/optional_fwd.hpp>
+#include <boost/thread/mutex.hpp>
 #include <map>
 #include <string>
-#include <tr1/unordered_map>
-#include <tr1/unordered_set>
+#include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 #include "kudu/common/partition.h"
@@ -30,14 +30,14 @@
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/master/master.pb.h"
 #include "kudu/master/ts_manager.h"
-#include "kudu/tserver/tablet_peer_lookup.h"
 #include "kudu/server/monitored_task.h"
+#include "kudu/tserver/tablet_peer_lookup.h"
 #include "kudu/util/cow_object.h"
 #include "kudu/util/locks.h"
 #include "kudu/util/monotime.h"
 #include "kudu/util/oid_generator.h"
-#include "kudu/util/status.h"
 #include "kudu/util/promise.h"
+#include "kudu/util/status.h"
 
 namespace kudu {
 
@@ -107,7 +107,7 @@ struct TabletReplica {
 class TabletInfo : public RefCountedThreadSafe<TabletInfo> {
  public:
   typedef PersistentTabletInfo cow_state;
-  typedef std::tr1::unordered_map<std::string, TabletReplica> ReplicaMap;
+  typedef std::unordered_map<std::string, TabletReplica> ReplicaMap;
 
   TabletInfo(const scoped_refptr<TableInfo>& table, const std::string& tablet_id);
 
@@ -262,7 +262,7 @@ class TableInfo : public RefCountedThreadSafe<TableInfo> {
   CowObject<PersistentTableInfo> metadata_;
 
   // List of pending tasks (e.g. create/alter tablet requests)
-  std::tr1::unordered_set<MonitoredTask*> pending_tasks_;
+  std::unordered_set<MonitoredTask*> pending_tasks_;
 
   DISALLOW_COPY_AND_ASSIGN(TableInfo);
 };
@@ -599,12 +599,12 @@ class CatalogManager : public tserver::TabletPeerLookupIf {
   mutable LockType lock_;
 
   // Table maps: table-id -> TableInfo and table-name -> TableInfo
-  typedef std::tr1::unordered_map<std::string, scoped_refptr<TableInfo> > TableInfoMap;
+  typedef std::unordered_map<std::string, scoped_refptr<TableInfo> > TableInfoMap;
   TableInfoMap table_ids_map_;
   TableInfoMap table_names_map_;
 
   // Tablet maps: tablet-id -> TabletInfo
-  typedef std::tr1::unordered_map<std::string, scoped_refptr<TabletInfo> > TabletInfoMap;
+  typedef std::unordered_map<std::string, scoped_refptr<TabletInfo> > TabletInfoMap;
   TabletInfoMap tablet_map_;
 
   Master *master_;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/master-path-handlers.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/master-path-handlers.cc b/src/kudu/master/master-path-handlers.cc
index 0baa73a..e44f89d 100644
--- a/src/kudu/master/master-path-handlers.cc
+++ b/src/kudu/master/master-path-handlers.cc
@@ -57,14 +57,14 @@ MasterPathHandlers::~MasterPathHandlers() {
 
 void MasterPathHandlers::HandleTabletServers(const Webserver::WebRequest& req,
                                              stringstream* output) {
-  vector<std::tr1::shared_ptr<TSDescriptor> > descs;
+  vector<std::shared_ptr<TSDescriptor> > descs;
   master_->ts_manager()->GetAllDescriptors(&descs);
 
   *output << "<h1>Tablet Servers</h1>\n";
 
   *output << "<table class='table table-striped'>\n";
   *output << "  <tr><th>UUID</th><th>Time since heartbeat</th><th>Registration</th></tr>\n";
-  BOOST_FOREACH(const std::tr1::shared_ptr<TSDescriptor>& desc, descs) {
+  BOOST_FOREACH(const std::shared_ptr<TSDescriptor>& desc, descs) {
     const string time_since_hb = StringPrintf("%.1fs", desc->TimeSinceHeartbeat().ToSeconds());
     TSRegistrationPB reg;
     desc->GetRegistration(&reg);

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/master-test-util.h
----------------------------------------------------------------------
diff --git a/src/kudu/master/master-test-util.h b/src/kudu/master/master-test-util.h
index 18f7f02..044df60 100644
--- a/src/kudu/master/master-test-util.h
+++ b/src/kudu/master/master-test-util.h
@@ -18,8 +18,6 @@
 #ifndef KUDU_MASTER_TEST_UTIL_H_
 #define KUDU_MASTER_TEST_UTIL_H_
 
-#include <boost/assign/list_of.hpp>
-
 #include <algorithm>
 #include <string>
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/master-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/master-test.cc b/src/kudu/master/master-test.cc
index a5c7c79..334e4fd 100644
--- a/src/kudu/master/master-test.cc
+++ b/src/kudu/master/master-test.cc
@@ -15,12 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 #include <gtest/gtest.h>
 
 #include <algorithm>
-#include <tr1/memory>
+#include <memory>
 #include <vector>
 
 #include "kudu/common/partial_row.h"
@@ -38,12 +37,11 @@
 #include "kudu/util/status.h"
 #include "kudu/util/test_util.h"
 
-using boost::assign::list_of;
-using std::string;
-using std::tr1::shared_ptr;
 using kudu::rpc::Messenger;
 using kudu::rpc::MessengerBuilder;
 using kudu::rpc::RpcController;
+using std::shared_ptr;
+using std::string;
 
 DECLARE_bool(catalog_manager_check_ts_count_for_create_table);
 
@@ -222,7 +220,7 @@ Status MasterTest::CreateTable(const string& table_name,
   KuduPartialRow split2(&schema);
   RETURN_NOT_OK(split2.SetInt32("key", 20));
 
-  return CreateTable(table_name, schema, list_of(split1)(split2));
+  return CreateTable(table_name, schema, { split1, split2 });
 }
 
 Status MasterTest::CreateTable(const string& table_name,
@@ -262,9 +260,9 @@ void MasterTest::DoListAllTables(ListTablesResponsePB* resp) {
 TEST_F(MasterTest, TestCatalog) {
   const char *kTableName = "testtb";
   const char *kOtherTableName = "tbtest";
-  const Schema kTableSchema(list_of(ColumnSchema("key", INT32))
-                                   (ColumnSchema("v1", UINT64))
-                                   (ColumnSchema("v2", STRING)),
+  const Schema kTableSchema({ ColumnSchema("key", INT32),
+                              ColumnSchema("v1", UINT64),
+                              ColumnSchema("v2", STRING) },
                             1);
 
   ASSERT_OK(CreateTable(kTableName, kTableSchema));
@@ -345,7 +343,7 @@ TEST_F(MasterTest, TestCatalog) {
 
 TEST_F(MasterTest, TestCreateTableCheckSplitRows) {
   const char *kTableName = "testtb";
-  const Schema kTableSchema(list_of(ColumnSchema("key", INT32))(ColumnSchema("val", INT32)), 1);
+  const Schema kTableSchema({ ColumnSchema("key", INT32), ColumnSchema("val", INT32) }, 1);
 
   // No duplicate split rows.
   {
@@ -353,7 +351,7 @@ TEST_F(MasterTest, TestCreateTableCheckSplitRows) {
     ASSERT_OK(split1.SetInt32("key", 1));
     KuduPartialRow split2(&kTableSchema);
     ASSERT_OK(split2.SetInt32("key", 2));
-    Status s = CreateTable(kTableName, kTableSchema, list_of(split1)(split1)(split2));
+    Status s = CreateTable(kTableName, kTableSchema, { split1, split1, split2 });
     ASSERT_TRUE(s.IsInvalidArgument()) << s.ToString();
     ASSERT_STR_CONTAINS(s.ToString(), "Duplicate split row");
   }
@@ -363,7 +361,7 @@ TEST_F(MasterTest, TestCreateTableCheckSplitRows) {
     KuduPartialRow split1 = KuduPartialRow(&kTableSchema);
     ASSERT_OK(split1.SetInt32("key", 1));
     KuduPartialRow split2(&kTableSchema);
-    Status s = CreateTable(kTableName, kTableSchema, list_of(split1)(split2));
+    Status s = CreateTable(kTableName, kTableSchema, { split1, split2 });
     ASSERT_TRUE(s.IsInvalidArgument());
     ASSERT_STR_CONTAINS(s.ToString(),
                         "Invalid argument: Split rows must contain a value for at "
@@ -375,7 +373,7 @@ TEST_F(MasterTest, TestCreateTableCheckSplitRows) {
     KuduPartialRow split = KuduPartialRow(&kTableSchema);
     ASSERT_OK(split.SetInt32("key", 1));
     ASSERT_OK(split.SetInt32("val", 1));
-    Status s = CreateTable(kTableName, kTableSchema, list_of(split));
+    Status s = CreateTable(kTableName, kTableSchema, { split });
     ASSERT_TRUE(s.IsInvalidArgument());
     ASSERT_STR_CONTAINS(s.ToString(),
                         "Invalid argument: Split rows may only contain values "
@@ -387,7 +385,7 @@ TEST_F(MasterTest, TestCreateTableInvalidKeyType) {
   const char *kTableName = "testtb";
 
   {
-    const Schema kTableSchema(list_of(ColumnSchema("key", BOOL)), 1);
+    const Schema kTableSchema({ ColumnSchema("key", BOOL) }, 1);
     Status s = CreateTable(kTableName, kTableSchema, vector<KuduPartialRow>());
     ASSERT_TRUE(s.IsInvalidArgument()) << s.ToString();
     ASSERT_STR_CONTAINS(s.ToString(),
@@ -395,7 +393,7 @@ TEST_F(MasterTest, TestCreateTableInvalidKeyType) {
   }
 
   {
-    const Schema kTableSchema(list_of(ColumnSchema("key", FLOAT)), 1);
+    const Schema kTableSchema({ ColumnSchema("key", FLOAT) }, 1);
     Status s = CreateTable(kTableName, kTableSchema, vector<KuduPartialRow>());
     ASSERT_TRUE(s.IsInvalidArgument()) << s.ToString();
     ASSERT_STR_CONTAINS(s.ToString(),
@@ -403,7 +401,7 @@ TEST_F(MasterTest, TestCreateTableInvalidKeyType) {
   }
 
   {
-    const Schema kTableSchema(list_of(ColumnSchema("key", DOUBLE)), 1);
+    const Schema kTableSchema({ ColumnSchema("key", DOUBLE) }, 1);
     Status s = CreateTable(kTableName, kTableSchema, vector<KuduPartialRow>());
     ASSERT_TRUE(s.IsInvalidArgument()) << s.ToString();
     ASSERT_STR_CONTAINS(s.ToString(),
@@ -437,7 +435,7 @@ TEST_F(MasterTest, TestCreateTableInvalidSchema) {
 // invalid.
 TEST_F(MasterTest, TestInvalidGetTableLocations) {
   const string kTableName = "test";
-  Schema schema(list_of(ColumnSchema("key", INT32)), 1);
+  Schema schema({ ColumnSchema("key", INT32) }, 1);
   ASSERT_OK(CreateTable(kTableName, schema));
   {
     GetTableLocationsRequestPB req;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/master.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/master.cc b/src/kudu/master/master.cc
index 83c70e0..45e553f 100644
--- a/src/kudu/master/master.cc
+++ b/src/kudu/master/master.cc
@@ -22,8 +22,8 @@
 #include <boost/foreach.hpp>
 #include <glog/logging.h>
 #include <list>
+#include <memory>
 #include <vector>
-#include <tr1/memory>
 
 #include "kudu/cfile/block_cache.h"
 #include "kudu/common/wire_protocol.h"
@@ -50,7 +50,7 @@ DEFINE_int32(master_registration_rpc_timeout_ms, 1500,
 TAG_FLAG(master_registration_rpc_timeout_ms, experimental);
 
 using std::min;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using std::vector;
 
 using kudu::consensus::RaftPeerPB;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/master.h
----------------------------------------------------------------------
diff --git a/src/kudu/master/master.h b/src/kudu/master/master.h
index 9079469..30627cf 100644
--- a/src/kudu/master/master.h
+++ b/src/kudu/master/master.h
@@ -18,7 +18,7 @@
 #define KUDU_MASTER_MASTER_H
 
 #include <string>
-#include <tr1/memory>
+#include <memory>
 #include <vector>
 
 #include "kudu/gutil/gscoped_ptr.h"
@@ -128,7 +128,7 @@ class Master : public server::ServerBase {
   MasterOptions opts_;
 
   // The maintenance manager for this master.
-  std::tr1::shared_ptr<MaintenanceManager> maintenance_manager_;
+  std::shared_ptr<MaintenanceManager> maintenance_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(Master);
 };

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/master_rpc.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/master_rpc.cc b/src/kudu/master/master_rpc.cc
index f60a870..0b41dd2 100644
--- a/src/kudu/master/master_rpc.cc
+++ b/src/kudu/master/master_rpc.cc
@@ -31,7 +31,7 @@
 #include "kudu/util/net/net_util.h"
 
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using std::string;
 using std::vector;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/master_rpc.h
----------------------------------------------------------------------
diff --git a/src/kudu/master/master_rpc.h b/src/kudu/master/master_rpc.h
index 6d2c5e6..6915afa 100644
--- a/src/kudu/master/master_rpc.h
+++ b/src/kudu/master/master_rpc.h
@@ -49,7 +49,7 @@ class GetMasterRegistrationRpc : public rpc::Rpc {
   GetMasterRegistrationRpc(const StatusCallback& user_cb,
                            const Sockaddr& addr,
                            const MonoTime& deadline,
-                           const std::tr1::shared_ptr<rpc::Messenger>& messenger,
+                           const std::shared_ptr<rpc::Messenger>& messenger,
                            ServerEntryPB* out);
 
   ~GetMasterRegistrationRpc();
@@ -100,7 +100,7 @@ class GetLeaderMasterRpc : public rpc::Rpc,
   GetLeaderMasterRpc(const LeaderCallback& user_cb,
                      const std::vector<Sockaddr>& addrs,
                      const MonoTime& deadline,
-                     const std::tr1::shared_ptr<rpc::Messenger>& messenger);
+                     const std::shared_ptr<rpc::Messenger>& messenger);
 
   virtual void SendRpc() OVERRIDE;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/master_service.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/master_service.cc b/src/kudu/master/master_service.cc
index 44621df..127641c 100644
--- a/src/kudu/master/master_service.cc
+++ b/src/kudu/master/master_service.cc
@@ -19,8 +19,8 @@
 
 #include <boost/foreach.hpp>
 #include <gflags/gflags.h>
+#include <memory>
 #include <string>
-#include <tr1/memory>
 #include <vector>
 
 #include "kudu/common/wire_protocol.h"
@@ -45,7 +45,7 @@ namespace master {
 using consensus::RaftPeerPB;
 using std::string;
 using std::vector;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 namespace {
 
@@ -338,9 +338,9 @@ void MasterServiceImpl::ListTabletServers(const ListTabletServersRequestPB* req,
     return;
   }
 
-  vector<std::tr1::shared_ptr<TSDescriptor> > descs;
+  vector<std::shared_ptr<TSDescriptor> > descs;
   server_->ts_manager()->GetAllDescriptors(&descs);
-  BOOST_FOREACH(const std::tr1::shared_ptr<TSDescriptor>& desc, descs) {
+  BOOST_FOREACH(const std::shared_ptr<TSDescriptor>& desc, descs) {
     ListTabletServersResponsePB::Entry* entry = resp->add_servers();
     desc->GetNodeInstancePB(entry->mutable_instance_id());
     desc->GetRegistration(entry->mutable_registration());

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/master_service.h
----------------------------------------------------------------------
diff --git a/src/kudu/master/master_service.h b/src/kudu/master/master_service.h
index db7a140..eddeb43 100644
--- a/src/kudu/master/master_service.h
+++ b/src/kudu/master/master_service.h
@@ -17,8 +17,6 @@
 #ifndef KUDU_MASTER_MASTER_SERVICE_H
 #define KUDU_MASTER_MASTER_SERVICE_H
 
-#include <tr1/memory>
-
 #include "kudu/gutil/macros.h"
 #include "kudu/master/master.service.h"
 #include "kudu/util/metrics.h"

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/mini_master.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/mini_master.cc b/src/kudu/master/mini_master.cc
index 604a16c..f8f5630 100644
--- a/src/kudu/master/mini_master.cc
+++ b/src/kudu/master/mini_master.cc
@@ -17,7 +17,6 @@
 
 #include "kudu/master/mini_master.h"
 
-#include <boost/assign/list_of.hpp>
 #include <string>
 
 #include <glog/logging.h>
@@ -82,7 +81,7 @@ Status MiniMaster::StartOnPorts(uint16_t rpc_port, uint16_t web_port,
   opts->rpc_opts.rpc_bind_addresses = Substitute("127.0.0.1:$0", rpc_port);
   opts->webserver_opts.port = web_port;
   opts->fs_opts.wal_path = fs_root_;
-  opts->fs_opts.data_paths = boost::assign::list_of(fs_root_);
+  opts->fs_opts.data_paths = { fs_root_ };
 
   gscoped_ptr<Master> server(new Master(*opts));
   RETURN_NOT_OK(server->Init());

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/sys_catalog-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/sys_catalog-test.cc b/src/kudu/master/sys_catalog-test.cc
index 6c14946..51eb737 100644
--- a/src/kudu/master/sys_catalog-test.cc
+++ b/src/kudu/master/sys_catalog-test.cc
@@ -15,12 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 #include <gtest/gtest.h>
 
 #include <algorithm>
-#include <tr1/memory>
+#include <memory>
 #include <vector>
 
 #include "kudu/common/wire_protocol.h"
@@ -37,7 +36,7 @@
 #include "kudu/rpc/messenger.h"
 
 using std::string;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using kudu::rpc::Messenger;
 using kudu::rpc::MessengerBuilder;
 using kudu::rpc::RpcController;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/sys_catalog.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/sys_catalog.cc b/src/kudu/master/sys_catalog.cc
index edda1e0..6db9c67 100644
--- a/src/kudu/master/sys_catalog.cc
+++ b/src/kudu/master/sys_catalog.cc
@@ -17,7 +17,6 @@
 
 #include "kudu/master/sys_catalog.h"
 
-#include <boost/assign/list_of.hpp>
 #include <gflags/gflags.h>
 #include <glog/logging.h>
 
@@ -56,7 +55,7 @@ using kudu::tablet::Tablet;
 using kudu::tablet::TabletPeer;
 using kudu::tserver::WriteRequestPB;
 using kudu::tserver::WriteResponsePB;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using strings::Substitute;
 
 namespace kudu {

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/ts_descriptor.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/ts_descriptor.cc b/src/kudu/master/ts_descriptor.cc
index 80ec69a..ba8a274 100644
--- a/src/kudu/master/ts_descriptor.cc
+++ b/src/kudu/master/ts_descriptor.cc
@@ -29,7 +29,7 @@
 
 #include <vector>
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 namespace kudu {
 namespace master {

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/ts_descriptor.h
----------------------------------------------------------------------
diff --git a/src/kudu/master/ts_descriptor.h b/src/kudu/master/ts_descriptor.h
index 19bf891..683f1e6 100644
--- a/src/kudu/master/ts_descriptor.h
+++ b/src/kudu/master/ts_descriptor.h
@@ -17,8 +17,8 @@
 #ifndef KUDU_MASTER_TS_DESCRIPTOR_H
 #define KUDU_MASTER_TS_DESCRIPTOR_H
 
+#include <memory>
 #include <string>
-#include <tr1/memory>
 
 #include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/util/locks.h"
@@ -83,12 +83,12 @@ class TSDescriptor {
   void GetNodeInstancePB(NodeInstancePB* instance_pb) const;
 
   // Return an RPC proxy to the tablet server admin service.
-  Status GetTSAdminProxy(const std::tr1::shared_ptr<rpc::Messenger>& messenger,
-                         std::tr1::shared_ptr<tserver::TabletServerAdminServiceProxy>* proxy);
+  Status GetTSAdminProxy(const std::shared_ptr<rpc::Messenger>& messenger,
+                         std::shared_ptr<tserver::TabletServerAdminServiceProxy>* proxy);
 
   // Return an RPC proxy to the consensus service.
-  Status GetConsensusProxy(const std::tr1::shared_ptr<rpc::Messenger>& messenger,
-                           std::tr1::shared_ptr<consensus::ConsensusServiceProxy>* proxy);
+  Status GetConsensusProxy(const std::shared_ptr<rpc::Messenger>& messenger,
+                           std::shared_ptr<consensus::ConsensusServiceProxy>* proxy);
 
  private:
   explicit TSDescriptor(const std::string& perm_id);
@@ -109,8 +109,8 @@ class TSDescriptor {
 
   gscoped_ptr<TSRegistrationPB> registration_;
 
-  std::tr1::shared_ptr<tserver::TabletServerAdminServiceProxy> ts_admin_proxy_;
-  std::tr1::shared_ptr<consensus::ConsensusServiceProxy> consensus_proxy_;
+  std::shared_ptr<tserver::TabletServerAdminServiceProxy> ts_admin_proxy_;
+  std::shared_ptr<consensus::ConsensusServiceProxy> consensus_proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(TSDescriptor);
 };

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/ts_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/ts_manager.cc b/src/kudu/master/ts_manager.cc
index 0898f70..150cae2 100644
--- a/src/kudu/master/ts_manager.cc
+++ b/src/kudu/master/ts_manager.cc
@@ -33,8 +33,8 @@ DEFINE_int32(tserver_unresponsive_timeout_ms, 60 * 1000,
              "selected when assigning replicas during table creation or re-replication.");
 TAG_FLAG(tserver_unresponsive_timeout_ms, advanced);
 
+using std::shared_ptr;
 using std::string;
-using std::tr1::shared_ptr;
 using std::vector;
 
 namespace kudu {
@@ -65,14 +65,14 @@ Status TSManager::LookupTS(const NodeInstancePB& instance,
 }
 
 bool TSManager::LookupTSByUUID(const string& uuid,
-                               std::tr1::shared_ptr<TSDescriptor>* ts_desc) {
+                               std::shared_ptr<TSDescriptor>* ts_desc) {
   boost::shared_lock<rw_spinlock> l(lock_);
   return FindCopy(servers_by_id_, uuid, ts_desc);
 }
 
 Status TSManager::RegisterTS(const NodeInstancePB& instance,
                              const TSRegistrationPB& registration,
-                             std::tr1::shared_ptr<TSDescriptor>* desc) {
+                             std::shared_ptr<TSDescriptor>* desc) {
   boost::lock_guard<rw_spinlock> l(lock_);
   const string& uuid = instance.permanent_uuid();
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/master/ts_manager.h
----------------------------------------------------------------------
diff --git a/src/kudu/master/ts_manager.h b/src/kudu/master/ts_manager.h
index b2de899..b2df8ae 100644
--- a/src/kudu/master/ts_manager.h
+++ b/src/kudu/master/ts_manager.h
@@ -17,9 +17,9 @@
 #ifndef KUDU_MASTER_TS_MANAGER_H
 #define KUDU_MASTER_TS_MANAGER_H
 
+#include <memory>
 #include <string>
-#include <tr1/unordered_map>
-#include <tr1/memory>
+#include <unordered_map>
 #include <vector>
 
 #include "kudu/gutil/macros.h"
@@ -36,7 +36,7 @@ namespace master {
 class TSDescriptor;
 class TSRegistrationPB;
 
-typedef std::vector<std::tr1::shared_ptr<TSDescriptor> > TSDescriptorVector;
+typedef std::vector<std::shared_ptr<TSDescriptor> > TSDescriptorVector;
 
 // Tracks the servers that the master has heard from, along with their
 // last heartbeat, etc.
@@ -58,28 +58,28 @@ class TSManager {
   // current instance ID for the TS, then a NotFound status is returned.
   // Otherwise, *desc is set and OK is returned.
   Status LookupTS(const NodeInstancePB& instance,
-                  std::tr1::shared_ptr<TSDescriptor>* desc);
+                  std::shared_ptr<TSDescriptor>* desc);
 
   // Lookup the tablet server descriptor for the given UUID.
   // Returns false if the TS has never registered.
   // Otherwise, *desc is set and returns true.
   bool LookupTSByUUID(const std::string& uuid,
-                        std::tr1::shared_ptr<TSDescriptor>* desc);
+                        std::shared_ptr<TSDescriptor>* desc);
 
   // Register or re-register a tablet server with the manager.
   //
   // If successful, *desc reset to the registered descriptor.
   Status RegisterTS(const NodeInstancePB& instance,
                     const TSRegistrationPB& registration,
-                    std::tr1::shared_ptr<TSDescriptor>* desc);
+                    std::shared_ptr<TSDescriptor>* desc);
 
   // Return all of the currently registered TS descriptors into the provided
   // list.
-  void GetAllDescriptors(std::vector<std::tr1::shared_ptr<TSDescriptor> >* descs) const;
+  void GetAllDescriptors(std::vector<std::shared_ptr<TSDescriptor> >* descs) const;
 
   // Return all of the currently registered TS descriptors that have sent a
   // heartbeat recently, indicating that they're alive and well.
-  void GetAllLiveDescriptors(std::vector<std::tr1::shared_ptr<TSDescriptor> >* descs) const;
+  void GetAllLiveDescriptors(std::vector<std::shared_ptr<TSDescriptor> >* descs) const;
 
   // Get the TS count.
   int GetCount() const;
@@ -87,8 +87,8 @@ class TSManager {
  private:
   mutable rw_spinlock lock_;
 
-  typedef std::tr1::unordered_map<
-    std::string, std::tr1::shared_ptr<TSDescriptor> > TSDescriptorMap;
+  typedef std::unordered_map<
+    std::string, std::shared_ptr<TSDescriptor> > TSDescriptorMap;
   TSDescriptorMap servers_by_id_;
 
   DISALLOW_COPY_AND_ASSIGN(TSManager);

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/acceptor_pool.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/acceptor_pool.cc b/src/kudu/rpc/acceptor_pool.cc
index 0365fe9..a144152 100644
--- a/src/kudu/rpc/acceptor_pool.cc
+++ b/src/kudu/rpc/acceptor_pool.cc
@@ -21,11 +21,9 @@
 #include <gflags/gflags.h>
 #include <glog/logging.h>
 #include <inttypes.h>
+#include <iostream>
 #include <pthread.h>
 #include <stdint.h>
-#include <tr1/memory>
-
-#include <iostream>
 #include <string>
 #include <vector>
 
@@ -40,7 +38,6 @@
 #include "kudu/util/thread.h"
 
 using google::protobuf::Message;
-using std::tr1::shared_ptr;
 using std::string;
 
 METRIC_DEFINE_counter(server, rpc_connections_accepted,

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/acceptor_pool.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/acceptor_pool.h b/src/kudu/rpc/acceptor_pool.h
index d161b52..7da78be 100644
--- a/src/kudu/rpc/acceptor_pool.h
+++ b/src/kudu/rpc/acceptor_pool.h
@@ -18,7 +18,6 @@
 #ifndef KUDU_RPC_ACCEPTOR_POOL_H
 #define KUDU_RPC_ACCEPTOR_POOL_H
 
-#include <tr1/memory>
 #include <vector>
 
 #include "kudu/gutil/atomicops.h"

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/auth_store.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/auth_store.cc b/src/kudu/rpc/auth_store.cc
index 527cefe..b4f9e10 100644
--- a/src/kudu/rpc/auth_store.cc
+++ b/src/kudu/rpc/auth_store.cc
@@ -18,7 +18,7 @@
 #include "kudu/rpc/auth_store.h"
 
 #include <string>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 #include "kudu/util/status.h"
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/auth_store.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/auth_store.h b/src/kudu/rpc/auth_store.h
index ec07ffc..b6e937f 100644
--- a/src/kudu/rpc/auth_store.h
+++ b/src/kudu/rpc/auth_store.h
@@ -18,8 +18,8 @@
 #ifndef KUDU_RPC_AUTH_STORE_H
 #define KUDU_RPC_AUTH_STORE_H
 
+#include <unordered_map>
 #include <string>
-#include <tr1/unordered_map>
 
 #include "kudu/gutil/macros.h"
 
@@ -30,7 +30,7 @@ class Status;
 namespace rpc {
 
 using std::string;
-using std::tr1::unordered_map;
+using std::unordered_map;
 
 // This class stores username / password pairs in memory for use in PLAIN SASL auth.
 // Add() is NOT thread safe.

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/connection.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/connection.cc b/src/kudu/rpc/connection.cc
index af49afb..738f501 100644
--- a/src/kudu/rpc/connection.cc
+++ b/src/kudu/rpc/connection.cc
@@ -45,7 +45,7 @@
 #include "kudu/util/status.h"
 #include "kudu/util/trace.h"
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using std::vector;
 using strings::Substitute;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/connection.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/connection.h b/src/kudu/rpc/connection.h
index 9fc2c74..9dbaf1f 100644
--- a/src/kudu/rpc/connection.h
+++ b/src/kudu/rpc/connection.h
@@ -20,9 +20,9 @@
 
 #include <boost/intrusive/list.hpp>
 #include <ev++.h>
+#include <memory>
 #include <stdint.h>
-#include <tr1/memory>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 #include <limits>
 #include <string>
@@ -108,7 +108,7 @@ class Connection : public RefCountedThreadSafe<Connection> {
   // marked failed.
   // Takes ownership of the 'call' object regardless of whether it succeeds or fails.
   // This may be called from a non-reactor thread.
-  void QueueOutboundCall(const std::tr1::shared_ptr<OutboundCall> &call);
+  void QueueOutboundCall(const std::shared_ptr<OutboundCall> &call);
 
   // Queue a call response back to the client on the server side.
   //
@@ -177,12 +177,12 @@ class Connection : public RefCountedThreadSafe<Connection> {
     void HandleTimeout(ev::timer &watcher, int revents);
 
     Connection *conn;
-    std::tr1::shared_ptr<OutboundCall> call;
+    std::shared_ptr<OutboundCall> call;
     ev::timer timeout_timer;
   };
 
-  typedef std::tr1::unordered_map<uint64_t, CallAwaitingResponse*> car_map_t;
-  typedef std::tr1::unordered_map<uint64_t, InboundCall*> inbound_call_map_t;
+  typedef std::unordered_map<uint64_t, CallAwaitingResponse*> car_map_t;
+  typedef std::unordered_map<uint64_t, InboundCall*> inbound_call_map_t;
 
   // Returns the next valid (positive) sequential call ID by incrementing a counter
   // and ensuring we roll over from INT32_MAX to 0.

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/inbound_call.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/inbound_call.cc b/src/kudu/rpc/inbound_call.cc
index f142c71..2aa0087 100644
--- a/src/kudu/rpc/inbound_call.cc
+++ b/src/kudu/rpc/inbound_call.cc
@@ -18,8 +18,7 @@
 #include "kudu/rpc/inbound_call.h"
 
 #include <boost/foreach.hpp>
-#include <tr1/memory>
-#include <vector>
+#include <memory>
 
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/rpc/connection.h"
@@ -35,7 +34,7 @@ using google::protobuf::FieldDescriptor;
 using google::protobuf::Message;
 using google::protobuf::MessageLite;
 using google::protobuf::io::CodedOutputStream;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using std::vector;
 using strings::Substitute;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/inbound_call.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/inbound_call.h b/src/kudu/rpc/inbound_call.h
index de0693f..88706d3 100644
--- a/src/kudu/rpc/inbound_call.h
+++ b/src/kudu/rpc/inbound_call.h
@@ -18,8 +18,6 @@
 #define KUDU_RPC_INBOUND_CALL_H
 
 #include <glog/logging.h>
-#include <tr1/memory>
-
 #include <string>
 #include <vector>
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/messenger.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/messenger.cc b/src/kudu/rpc/messenger.cc
index 9ea8cbe..dfb6860 100644
--- a/src/kudu/rpc/messenger.cc
+++ b/src/kudu/rpc/messenger.cc
@@ -51,7 +51,7 @@
 #include "kudu/util/trace.h"
 
 using std::string;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using strings::Substitute;
 
 DEFINE_int32(rpc_default_keepalive_time_ms, 65000,

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/messenger.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/messenger.h b/src/kudu/rpc/messenger.h
index 4208e4a..82dd36b 100644
--- a/src/kudu/rpc/messenger.h
+++ b/src/kudu/rpc/messenger.h
@@ -17,9 +17,9 @@
 #ifndef KUDU_RPC_MESSENGER_H
 #define KUDU_RPC_MESSENGER_H
 
+#include <memory>
 #include <stdint.h>
-#include <tr1/memory>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 #include <list>
 #include <string>
@@ -92,7 +92,7 @@ class MessengerBuilder {
   // Set metric entity for use by RPC systems.
   MessengerBuilder &set_metric_entity(const scoped_refptr<MetricEntity>& metric_entity);
 
-  Status Build(std::tr1::shared_ptr<Messenger> *msgr);
+  Status Build(std::shared_ptr<Messenger> *msgr);
 
  private:
   Status Build(Messenger **msgr);
@@ -119,8 +119,8 @@ class Messenger {
   friend class MessengerBuilder;
   friend class Proxy;
   friend class Reactor;
-  typedef std::vector<std::tr1::shared_ptr<AcceptorPool> > acceptor_vec_t;
-  typedef std::tr1::unordered_map<std::string, scoped_refptr<RpcService> > RpcServicesMap;
+  typedef std::vector<std::shared_ptr<AcceptorPool> > acceptor_vec_t;
+  typedef std::unordered_map<std::string, scoped_refptr<RpcService> > RpcServicesMap;
 
   static const uint64_t UNKNOWN_CALL_ID = 0;
 
@@ -141,7 +141,7 @@ class Messenger {
   // NOTE: the returned pool is not initially started. You must call
   // pool->Start(...) to begin accepting connections.
   Status AddAcceptorPool(const Sockaddr &accept_addr,
-                         std::tr1::shared_ptr<AcceptorPool>* pool);
+                         std::shared_ptr<AcceptorPool>* pool);
 
   // Register a new RpcService to handle inbound requests.
   Status RegisterService(const std::string& service_name,
@@ -154,7 +154,7 @@ class Messenger {
 
   // Queue a call for transmission. This will pick the appropriate reactor,
   // and enqueue a task on that reactor to assign and send the call.
-  void QueueOutboundCall(const std::tr1::shared_ptr<OutboundCall> &call);
+  void QueueOutboundCall(const std::shared_ptr<OutboundCall> &call);
 
   // Enqueue a call for processing on the server.
   void QueueInboundCall(gscoped_ptr<InboundCall> call);
@@ -265,7 +265,7 @@ class Messenger {
   // do so. So, handing out a normal shared_ptr to users would force the Messenger
   // destructor to Join() the reactor threads, which causes a problem if the user
   // tries to destruct the Messenger from within a Reactor thread itself.
-  std::tr1::shared_ptr<Messenger> retain_self_;
+  std::shared_ptr<Messenger> retain_self_;
 
   DISALLOW_COPY_AND_ASSIGN(Messenger);
 };

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/mt-rpc-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/mt-rpc-test.cc b/src/kudu/rpc/mt-rpc-test.cc
index 330da67..f6d1977 100644
--- a/src/kudu/rpc/mt-rpc-test.cc
+++ b/src/kudu/rpc/mt-rpc-test.cc
@@ -32,7 +32,7 @@ METRIC_DECLARE_counter(rpc_connections_accepted);
 METRIC_DECLARE_counter(rpcs_queue_overflow);
 
 using std::string;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using strings::Substitute;
 
 namespace kudu {

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/negotiation.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/negotiation.cc b/src/kudu/rpc/negotiation.cc
index c3ee0a0..e2cbb4a 100644
--- a/src/kudu/rpc/negotiation.cc
+++ b/src/kudu/rpc/negotiation.cc
@@ -47,7 +47,7 @@ TAG_FLAG(rpc_trace_negotiation, experimental);
 namespace kudu {
 namespace rpc {
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using strings::Substitute;
 
 // Client: Send ConnectionContextPB message based on information stored in the Connection object.

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/outbound_call.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/outbound_call.h b/src/kudu/rpc/outbound_call.h
index ac89a27..7596e1c 100644
--- a/src/kudu/rpc/outbound_call.h
+++ b/src/kudu/rpc/outbound_call.h
@@ -19,7 +19,6 @@
 
 #include <string>
 #include <vector>
-#include <tr1/memory>
 
 #include <glog/logging.h>
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/protoc-gen-krpc.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/protoc-gen-krpc.cc b/src/kudu/rpc/protoc-gen-krpc.cc
index e3e58d1..e7fbcc1 100644
--- a/src/kudu/rpc/protoc-gen-krpc.cc
+++ b/src/kudu/rpc/protoc-gen-krpc.cc
@@ -29,10 +29,9 @@
 #include <google/protobuf/io/printer.h>
 #include <google/protobuf/io/zero_copy_stream.h>
 #include <google/protobuf/stubs/common.h>
-#include <tr1/memory>
-
 #include <iostream>
 #include <map>
+#include <memory>
 #include <sstream>
 #include <string>
 
@@ -48,12 +47,12 @@
 #include "kudu/util/string_case.h"
 
 using google::protobuf::FileDescriptor;
+using google::protobuf::io::Printer;
 using google::protobuf::MethodDescriptor;
 using google::protobuf::ServiceDescriptor;
-using google::protobuf::io::Printer;
 using std::map;
+using std::shared_ptr;
 using std::string;
-using std::tr1::shared_ptr;
 using std::vector;
 
 namespace kudu {
@@ -573,7 +572,7 @@ class CodeGenerator : public ::google::protobuf::compiler::CodeGenerator {
       Print(printer, *subs,
         "class $service_name$Proxy {\n"
         " public:\n"
-        "  $service_name$Proxy(const std::tr1::shared_ptr< ::kudu::rpc::Messenger>\n"
+        "  $service_name$Proxy(const std::shared_ptr< ::kudu::rpc::Messenger>\n"
         "                &messenger, const ::kudu::Sockaddr &sockaddr);\n"
         "  ~$service_name$Proxy();\n"
         "\n"
@@ -636,7 +635,7 @@ class CodeGenerator : public ::google::protobuf::compiler::CodeGenerator {
       subs->PushService(service);
       Print(printer, *subs,
         "$service_name$Proxy::$service_name$Proxy(\n"
-        "   const std::tr1::shared_ptr< ::kudu::rpc::Messenger> &messenger,\n"
+        "   const std::shared_ptr< ::kudu::rpc::Messenger> &messenger,\n"
         "   const ::kudu::Sockaddr &remote)\n"
         "  : proxy_(messenger, remote, \"$full_service_name$\") {\n"
         "}\n"

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/proxy.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/proxy.cc b/src/kudu/rpc/proxy.cc
index 6216d0a..4de345e 100644
--- a/src/kudu/rpc/proxy.cc
+++ b/src/kudu/rpc/proxy.cc
@@ -20,8 +20,8 @@
 #include <boost/bind.hpp>
 #include <glog/logging.h>
 #include <inttypes.h>
+#include <memory>
 #include <stdint.h>
-#include <tr1/memory>
 
 #include <iostream>
 #include <sstream>
@@ -40,12 +40,12 @@
 
 using google::protobuf::Message;
 using std::string;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 namespace kudu {
 namespace rpc {
 
-Proxy::Proxy(const std::tr1::shared_ptr<Messenger>& messenger,
+Proxy::Proxy(const std::shared_ptr<Messenger>& messenger,
              const Sockaddr& remote,
              const string& service_name)
   : service_name_(service_name),

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/proxy.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/proxy.h b/src/kudu/rpc/proxy.h
index 32d988d..ae2f8ea 100644
--- a/src/kudu/rpc/proxy.h
+++ b/src/kudu/rpc/proxy.h
@@ -18,7 +18,7 @@
 #ifndef KUDU_RPC_PROXY_H
 #define KUDU_RPC_PROXY_H
 
-#include <tr1/memory>
+#include <memory>
 #include <string>
 
 #include "kudu/gutil/atomicops.h"
@@ -55,7 +55,7 @@ class Messenger;
 // After initialization, multiple threads may make calls using the same proxy object.
 class Proxy {
  public:
-  Proxy(const std::tr1::shared_ptr<Messenger>& messenger,
+  Proxy(const std::shared_ptr<Messenger>& messenger,
         const Sockaddr& remote,
         const std::string& service_name);
   ~Proxy();
@@ -107,7 +107,7 @@ class Proxy {
 
  private:
   const std::string service_name_;
-  std::tr1::shared_ptr<Messenger> messenger_;
+  std::shared_ptr<Messenger> messenger_;
   ConnectionId conn_id_;
   mutable Atomic32 is_started_;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/reactor-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/reactor-test.cc b/src/kudu/rpc/reactor-test.cc
index 226227f..c7af518 100644
--- a/src/kudu/rpc/reactor-test.cc
+++ b/src/kudu/rpc/reactor-test.cc
@@ -20,7 +20,7 @@
 #include "kudu/rpc/rpc-test-base.h"
 #include "kudu/util/countdown_latch.h"
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 namespace kudu {
 namespace rpc {

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/reactor.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/reactor.cc b/src/kudu/rpc/reactor.cc
index e66d45c..bcdb3e8 100644
--- a/src/kudu/rpc/reactor.cc
+++ b/src/kudu/rpc/reactor.cc
@@ -53,7 +53,7 @@
 #include "kudu/util/net/socket.h"
 
 using std::string;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 DEFINE_int64(rpc_negotiation_timeout_ms, 3000,
              "Timeout for negotiating an RPC connection.");

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/reactor.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/reactor.h b/src/kudu/rpc/reactor.h
index be6b416..a627327 100644
--- a/src/kudu/rpc/reactor.h
+++ b/src/kudu/rpc/reactor.h
@@ -20,12 +20,11 @@
 #include <boost/intrusive/list.hpp>
 #include <boost/utility.hpp>
 #include <ev++.h>
-#include <stdint.h>
-#include <tr1/memory>
-
 #include <list>
 #include <map>
+#include <memory>
 #include <set>
+#include <stdint.h>
 #include <string>
 
 #include "kudu/gutil/ref_counted.h"
@@ -124,8 +123,8 @@ class ReactorThread {
   friend class Connection;
 
   // Client-side connection map.
-  typedef std::tr1::unordered_map<ConnectionId, scoped_refptr<Connection>,
-                                  ConnectionIdHash, ConnectionIdEqual> conn_map_t;
+  typedef std::unordered_map<ConnectionId, scoped_refptr<Connection>,
+                             ConnectionIdHash, ConnectionIdEqual> conn_map_t;
 
   ReactorThread(Reactor *reactor, const MessengerBuilder &bld);
 
@@ -220,7 +219,7 @@ class ReactorThread {
 
   // Assign a new outbound call to the appropriate connection object.
   // If this fails, the call is marked failed and completed.
-  void AssignOutboundCall(const std::tr1::shared_ptr<OutboundCall> &call);
+  void AssignOutboundCall(const std::shared_ptr<OutboundCall> &call);
 
   // Register a new connection.
   void RegisterConnection(const scoped_refptr<Connection>& conn);
@@ -270,7 +269,7 @@ class ReactorThread {
 // A Reactor manages a ReactorThread
 class Reactor {
  public:
-  Reactor(const std::tr1::shared_ptr<Messenger>& messenger,
+  Reactor(const std::shared_ptr<Messenger>& messenger,
           int index,
           const MessengerBuilder &bld);
   Status Init();
@@ -296,7 +295,7 @@ class Reactor {
 
   // Queue a new call to be sent. If the reactor is already shut down, marks
   // the call as failed.
-  void QueueOutboundCall(const std::tr1::shared_ptr<OutboundCall> &call);
+  void QueueOutboundCall(const std::shared_ptr<OutboundCall> &call);
 
   // Schedule the given task's Run() method to be called on the
   // reactor thread.
@@ -332,7 +331,7 @@ class Reactor {
   mutable LockType lock_;
 
   // parent messenger
-  std::tr1::shared_ptr<Messenger> messenger_;
+  std::shared_ptr<Messenger> messenger_;
 
   const std::string name_;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/rpc-bench.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc-bench.cc b/src/kudu/rpc/rpc-bench.cc
index 3bb3c58..63afb31 100644
--- a/src/kudu/rpc/rpc-bench.cc
+++ b/src/kudu/rpc/rpc-bench.cc
@@ -28,7 +28,7 @@
 #include "kudu/util/test_util.h"
 
 using std::string;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 namespace kudu {
 namespace rpc {

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/rpc-test-base.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc-test-base.h b/src/kudu/rpc/rpc-test-base.h
index 5b68722..cf02fa4 100644
--- a/src/kudu/rpc/rpc-test-base.h
+++ b/src/kudu/rpc/rpc-test-base.h
@@ -19,18 +19,19 @@
 
 #include <algorithm>
 #include <list>
+#include <memory>
 #include <string>
 
 #include "kudu/rpc/acceptor_pool.h"
 #include "kudu/rpc/messenger.h"
 #include "kudu/rpc/proxy.h"
 #include "kudu/rpc/reactor.h"
-#include "kudu/rpc/rtest.pb.h"
-#include "kudu/rpc/rtest.proxy.h"
-#include "kudu/rpc/rtest.service.h"
 #include "kudu/rpc/remote_method.h"
 #include "kudu/rpc/rpc_context.h"
 #include "kudu/rpc/rpc_sidecar.h"
+#include "kudu/rpc/rtest.pb.h"
+#include "kudu/rpc/rtest.proxy.h"
+#include "kudu/rpc/rtest.service.h"
 #include "kudu/rpc/service_if.h"
 #include "kudu/rpc/service_pool.h"
 #include "kudu/util/faststring.h"
@@ -43,14 +44,14 @@
 
 namespace kudu { namespace rpc {
 
-using kudu::rpc_test::AddRequestPB;
 using kudu::rpc_test::AddRequestPartialPB;
+using kudu::rpc_test::AddRequestPB;
 using kudu::rpc_test::AddResponsePB;
-using kudu::rpc_test::EchoRequestPB;
-using kudu::rpc_test::EchoResponsePB;
 using kudu::rpc_test::CalculatorError;
 using kudu::rpc_test::CalculatorServiceIf;
 using kudu::rpc_test::CalculatorServiceProxy;
+using kudu::rpc_test::EchoRequestPB;
+using kudu::rpc_test::EchoResponsePB;
 using kudu::rpc_test::PanicRequestPB;
 using kudu::rpc_test::PanicResponsePB;
 using kudu::rpc_test::SendTwoStringsRequestPB;
@@ -281,7 +282,7 @@ class RpcTestBase : public KuduTest {
   }
 
  protected:
-  std::tr1::shared_ptr<Messenger> CreateMessenger(const string &name,
+  std::shared_ptr<Messenger> CreateMessenger(const string &name,
                                         int n_reactors = 1) {
     MessengerBuilder bld(name);
     bld.set_num_reactors(n_reactors);
@@ -290,7 +291,7 @@ class RpcTestBase : public KuduTest {
     bld.set_coarse_timer_granularity(MonoDelta::FromMilliseconds(
                                        std::min(keepalive_time_ms_, 100)));
     bld.set_metric_entity(metric_entity_);
-    std::tr1::shared_ptr<Messenger> messenger;
+    std::shared_ptr<Messenger> messenger;
     CHECK_OK(bld.Build(&messenger));
     return messenger;
   }
@@ -395,7 +396,7 @@ class RpcTestBase : public KuduTest {
   template<class ServiceClass>
   void DoStartTestServer(Sockaddr *server_addr) {
     server_messenger_ = CreateMessenger("TestServer", n_server_reactor_threads_);
-    std::tr1::shared_ptr<AcceptorPool> pool;
+    std::shared_ptr<AcceptorPool> pool;
     ASSERT_OK(server_messenger_->AddAcceptorPool(Sockaddr(), &pool));
     ASSERT_OK(pool->Start(2));
     *server_addr = pool->bind_address();
@@ -410,7 +411,7 @@ class RpcTestBase : public KuduTest {
 
  protected:
   string service_name_;
-  std::tr1::shared_ptr<Messenger> server_messenger_;
+  std::shared_ptr<Messenger> server_messenger_;
   scoped_refptr<ServicePool> service_pool_;
   int n_worker_threads_;
   int n_server_reactor_threads_;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/rpc-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc-test.cc b/src/kudu/rpc/rpc-test.cc
index 8d3f023..ab0f49a 100644
--- a/src/kudu/rpc/rpc-test.cc
+++ b/src/kudu/rpc/rpc-test.cc
@@ -17,8 +17,9 @@
 
 #include "kudu/rpc/rpc-test-base.h"
 
+#include <memory>
 #include <string>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 #include <boost/foreach.hpp>
 #include <boost/ptr_container/ptr_vector.hpp>
@@ -35,8 +36,8 @@ METRIC_DECLARE_histogram(handler_latency_kudu_rpc_test_CalculatorService_Sleep);
 METRIC_DECLARE_histogram(rpc_incoming_queue_time);
 
 using std::string;
-using std::tr1::shared_ptr;
-using std::tr1::unordered_map;
+using std::shared_ptr;
+using std::unordered_map;
 
 namespace kudu {
 namespace rpc {

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/rpc.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc.cc b/src/kudu/rpc/rpc.cc
index 5018e01..3f19cc7 100644
--- a/src/kudu/rpc/rpc.cc
+++ b/src/kudu/rpc/rpc.cc
@@ -25,7 +25,7 @@
 #include "kudu/rpc/messenger.h"
 #include "kudu/rpc/rpc_header.pb.h"
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using strings::Substitute;
 using strings::SubstituteAndAppend;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/rpc.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc.h b/src/kudu/rpc/rpc.h
index f61315c..0926e7f 100644
--- a/src/kudu/rpc/rpc.h
+++ b/src/kudu/rpc/rpc.h
@@ -17,6 +17,7 @@
 #ifndef KUDU_RPC_RPC_H
 #define KUDU_RPC_RPC_H
 
+#include <memory>
 #include <string>
 
 #include "kudu/gutil/callback.h"
@@ -37,7 +38,7 @@ class Rpc;
 class RpcRetrier {
  public:
   RpcRetrier(const MonoTime& deadline,
-             const std::tr1::shared_ptr<rpc::Messenger>& messenger)
+             const std::shared_ptr<rpc::Messenger>& messenger)
     : attempt_num_(1),
       deadline_(deadline),
       messenger_(messenger) {
@@ -72,7 +73,7 @@ class RpcRetrier {
 
   const MonoTime& deadline() const { return deadline_; }
 
-  const std::tr1::shared_ptr<Messenger>& messenger() const {
+  const std::shared_ptr<Messenger>& messenger() const {
     return messenger_;
   }
 
@@ -92,7 +93,7 @@ class RpcRetrier {
   MonoTime deadline_;
 
   // Messenger to use when sending the RPC.
-  std::tr1::shared_ptr<Messenger> messenger_;
+  std::shared_ptr<Messenger> messenger_;
 
   // RPC controller to use when sending the RPC.
   RpcController controller_;
@@ -108,7 +109,7 @@ class RpcRetrier {
 class Rpc {
  public:
   Rpc(const MonoTime& deadline,
-      const std::tr1::shared_ptr<rpc::Messenger>& messenger)
+      const std::shared_ptr<rpc::Messenger>& messenger)
   : retrier_(deadline, messenger) {
   }
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/rpc_controller.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc_controller.h b/src/kudu/rpc/rpc_controller.h
index 6a60cb1..99b4ed4 100644
--- a/src/kudu/rpc/rpc_controller.h
+++ b/src/kudu/rpc/rpc_controller.h
@@ -18,7 +18,7 @@
 #define KUDU_RPC_RPC_CONTROLLER_H
 
 #include <glog/logging.h>
-#include <tr1/memory>
+#include <memory>
 
 #include "kudu/gutil/macros.h"
 #include "kudu/util/locks.h"
@@ -119,7 +119,7 @@ class RpcController {
   mutable simple_spinlock lock_;
 
   // Once the call is sent, it is tracked here.
-  std::tr1::shared_ptr<OutboundCall> call_;
+  std::shared_ptr<OutboundCall> call_;
 
   DISALLOW_COPY_AND_ASSIGN(RpcController);
 };

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/rpc_stub-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc_stub-test.cc b/src/kudu/rpc/rpc_stub-test.cc
index 1991e31..e0fc5fc 100644
--- a/src/kudu/rpc/rpc_stub-test.cc
+++ b/src/kudu/rpc/rpc_stub-test.cc
@@ -37,7 +37,7 @@ DEFINE_bool(is_panic_test_child, false, "Used by TestRpcPanic");
 DECLARE_bool(socket_inject_short_recvs);
 
 using boost::ptr_vector;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using std::vector;
 
 namespace kudu {

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/sasl_server.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/sasl_server.cc b/src/kudu/rpc/sasl_server.cc
index 869d539..42e3b57 100644
--- a/src/kudu/rpc/sasl_server.cc
+++ b/src/kudu/rpc/sasl_server.cc
@@ -17,16 +17,13 @@
 
 #include "kudu/rpc/sasl_server.h"
 
-#include <string.h>
-
-#include <limits>
-#include <set>
-#include <string>
-
 #include <boost/foreach.hpp>
 #include <glog/logging.h>
 #include <google/protobuf/message_lite.h>
+#include <limits>
 #include <sasl/sasl.h>
+#include <set>
+#include <string>
 
 #include "kudu/gutil/endian.h"
 #include "kudu/gutil/map-util.h"

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/sasl_server.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/sasl_server.h b/src/kudu/rpc/sasl_server.h
index 9a1f71e..159da4e 100644
--- a/src/kudu/rpc/sasl_server.h
+++ b/src/kudu/rpc/sasl_server.h
@@ -18,9 +18,8 @@
 #ifndef KUDU_RPC_SASL_SERVER_H
 #define KUDU_RPC_SASL_SERVER_H
 
-#include <string>
-#include <tr1/memory>
 #include <set>
+#include <string>
 #include <vector>
 
 #include <sasl/sasl.h>

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/service_pool.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/service_pool.cc b/src/kudu/rpc/service_pool.cc
index a9eebc6..a1ba072 100644
--- a/src/kudu/rpc/service_pool.cc
+++ b/src/kudu/rpc/service_pool.cc
@@ -19,8 +19,7 @@
 
 #include <boost/foreach.hpp>
 #include <glog/logging.h>
-#include <tr1/memory>
-
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -35,7 +34,7 @@
 #include "kudu/util/thread.h"
 #include "kudu/util/trace.h"
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using strings::Substitute;
 
 METRIC_DEFINE_histogram(server, rpc_incoming_queue_time,

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/rpc/service_pool.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/service_pool.h b/src/kudu/rpc/service_pool.h
index 8bb4c9d..54e76e0 100644
--- a/src/kudu/rpc/service_pool.h
+++ b/src/kudu/rpc/service_pool.h
@@ -18,7 +18,6 @@
 #ifndef KUDU_SERVICE_POOL_H
 #define KUDU_SERVICE_POOL_H
 
-#include <tr1/memory>
 #include <string>
 #include <vector>
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/server/default-path-handlers.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/default-path-handlers.cc b/src/kudu/server/default-path-handlers.cc
index 97bdc41..89fa8b2 100644
--- a/src/kudu/server/default-path-handlers.cc
+++ b/src/kudu/server/default-path-handlers.cc
@@ -29,15 +29,15 @@
 
 #include "kudu/server/default-path-handlers.h"
 
-#include <sstream>
-#include <string>
-#include <fstream>
-#include <sys/stat.h>
 #include <boost/algorithm/string.hpp>
 #include <boost/bind.hpp>
 #include <boost/foreach.hpp>
+#include <fstream>
 #include <gperftools/malloc_extension.h>
-#include <tr1/memory>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <sys/stat.h>
 #include <vector>
 
 #include "kudu/gutil/map-util.h"
@@ -67,7 +67,7 @@ TAG_FLAG(web_log_bytes, runtime);
 
 namespace kudu {
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 namespace {
 // Html/Text formatting tags

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/server/generic_service.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/generic_service.cc b/src/kudu/server/generic_service.cc
index d9d29a1..4d1d9f3 100644
--- a/src/kudu/server/generic_service.cc
+++ b/src/kudu/server/generic_service.cc
@@ -19,7 +19,7 @@
 
 #include <gflags/gflags.h>
 #include <string>
-#include <tr1/unordered_set>
+#include <unordered_set>
 
 #include "kudu/gutil/map-util.h"
 #include "kudu/rpc/rpc_context.h"
@@ -32,7 +32,7 @@ DECLARE_bool(use_mock_wall_clock);
 DECLARE_bool(use_hybrid_clock);
 
 using std::string;
-using std::tr1::unordered_set;
+using std::unordered_set;
 
 #ifdef COVERAGE_BUILD
 extern "C" void __gcov_flush(void);

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/server/rpc_server.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/rpc_server.cc b/src/kudu/server/rpc_server.cc
index 627f1ad..c95f532 100644
--- a/src/kudu/server/rpc_server.cc
+++ b/src/kudu/server/rpc_server.cc
@@ -35,12 +35,12 @@
 #include "kudu/util/net/sockaddr.h"
 #include "kudu/util/status.h"
 
-using std::string;
-using std::tr1::shared_ptr;
-using std::vector;
 using kudu::rpc::AcceptorPool;
 using kudu::rpc::Messenger;
 using kudu::rpc::ServiceIf;
+using std::shared_ptr;
+using std::string;
+using std::vector;
 using strings::Substitute;
 
 DEFINE_string(rpc_bind_addresses, "0.0.0.0",
@@ -89,7 +89,7 @@ string RpcServer::ToString() const {
   return "RpcServer";
 }
 
-Status RpcServer::Init(const std::tr1::shared_ptr<Messenger>& messenger) {
+Status RpcServer::Init(const shared_ptr<Messenger>& messenger) {
   CHECK_EQ(server_state_, UNINITIALIZED);
   messenger_ = messenger;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/server/rpc_server.h
----------------------------------------------------------------------
diff --git a/src/kudu/server/rpc_server.h b/src/kudu/server/rpc_server.h
index cda53dc..5ba8250 100644
--- a/src/kudu/server/rpc_server.h
+++ b/src/kudu/server/rpc_server.h
@@ -17,8 +17,8 @@
 #ifndef KUDU_RPC_SERVER_H
 #define KUDU_RPC_SERVER_H
 
+#include <memory>
 #include <string>
-#include <tr1/memory>
 #include <vector>
 
 #include "kudu/gutil/gscoped_ptr.h"
@@ -50,7 +50,7 @@ class RpcServer {
   explicit RpcServer(const RpcServerOptions& opts);
   ~RpcServer();
 
-  Status Init(const std::tr1::shared_ptr<rpc::Messenger>& messenger);
+  Status Init(const std::shared_ptr<rpc::Messenger>& messenger);
   // Services need to be registered after Init'ing, but before Start'ing.
   // The service's ownership will be given to a ServicePool.
   Status RegisterService(gscoped_ptr<rpc::ServiceIf> service);
@@ -80,12 +80,12 @@ class RpcServer {
   ServerState server_state_;
 
   const RpcServerOptions options_;
-  std::tr1::shared_ptr<rpc::Messenger> messenger_;
+  std::shared_ptr<rpc::Messenger> messenger_;
 
   // Parsed addresses to bind RPC to. Set by Init()
   std::vector<Sockaddr> rpc_bind_addresses_;
 
-  std::vector<std::tr1::shared_ptr<rpc::AcceptorPool> > acceptor_pools_;
+  std::vector<std::shared_ptr<rpc::AcceptorPool> > acceptor_pools_;
 
   DISALLOW_COPY_AND_ASSIGN(RpcServer);
 };



Mime
View raw message