kudu-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From a...@apache.org
Subject [kudu] branch master updated: replace gscoped_ptr with std::unique_ptr
Date Tue, 10 Mar 2020 06:44:23 GMT
This is an automated email from the ASF dual-hosted git repository.

adar pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/kudu.git


The following commit(s) were added to refs/heads/master by this push:
     new eaed5fb  replace gscoped_ptr with std::unique_ptr
eaed5fb is described below

commit eaed5fb514e70a837cdd1ef8f39f371fddabc25a
Author: Adar Dembo <adar@cloudera.com>
AuthorDate: Mon Mar 9 00:06:25 2020 -0700

    replace gscoped_ptr with std::unique_ptr
    
    The remaining usages are in gutil, where we've imported code wholesale which
    contained gscoped_ptr and I'm loathe to remove it right now.
    
    Given the high number of touched files, there are also a fair number of iwyu
    and clang-tidy fixups in this patch.
    
    Change-Id: I9a35557b49dba7cc6a0c131841ae3c96230bb2fc
    Reviewed-on: http://gerrit.cloudera.org:8080/15387
    Reviewed-by: Alexey Serbin <aserbin@cloudera.com>
    Tested-by: Adar Dembo <adar@cloudera.com>
---
 docs/design-docs/cpp-client.md                     |  6 +-
 src/kudu/benchmarks/tpch/rpc_line_item_dao-test.cc | 27 +++++----
 src/kudu/benchmarks/tpch/rpc_line_item_dao.cc      | 53 +++++++++---------
 src/kudu/benchmarks/tpch/rpc_line_item_dao.h       | 21 ++++---
 src/kudu/benchmarks/tpch/tpch1.cc                  | 14 ++---
 src/kudu/benchmarks/tpch/tpch_real_world.cc        | 33 ++++++-----
 src/kudu/cfile/binary_dict_block.h                 | 13 ++---
 src/kudu/cfile/block_cache.cc                      |  1 -
 src/kudu/cfile/block_cache.h                       |  9 +--
 src/kudu/cfile/bshuf_block.h                       |  1 +
 src/kudu/cfile/cfile-test-base.h                   | 16 ++----
 src/kudu/cfile/cfile-test.cc                       | 13 ++---
 src/kudu/cfile/cfile_reader.cc                     |  1 -
 src/kudu/cfile/cfile_reader.h                      | 19 +++----
 src/kudu/cfile/cfile_writer.h                      | 17 ++----
 src/kudu/cfile/encoding-test.cc                    | 64 +++++++++++-----------
 src/kudu/cfile/index-test.cc                       | 13 +++--
 src/kudu/client/client.cc                          |  3 +-
 src/kudu/client/master_rpc.cc                      | 14 ++---
 src/kudu/client/meta_cache.cc                      | 31 +++++------
 src/kudu/client/predicate-test.cc                  |  3 +-
 src/kudu/client/scan_predicate.cc                  |  1 -
 src/kudu/client/scan_token-test.cc                 |  3 +-
 src/kudu/client/schema.cc                          |  9 +--
 src/kudu/client/write_op.cc                        |  9 +--
 src/kudu/codegen/code_cache.cc                     |  1 -
 src/kudu/codegen/code_cache.h                      | 12 ++--
 src/kudu/codegen/code_generator.cc                 |  7 ++-
 src/kudu/codegen/codegen-test.cc                   | 20 ++++---
 src/kudu/codegen/compilation_manager.cc            |  4 +-
 src/kudu/codegen/compilation_manager.h             |  3 +-
 src/kudu/consensus/consensus-test-util.h           | 20 +++----
 src/kudu/consensus/consensus_peers-test.cc         |  8 +--
 src/kudu/consensus/consensus_peers.cc              | 16 +++---
 src/kudu/consensus/consensus_peers.h               | 21 +++----
 src/kudu/consensus/consensus_queue-test.cc         |  5 +-
 src/kudu/consensus/consensus_queue.h               |  3 +-
 src/kudu/consensus/leader_election-test.cc         |  7 +--
 src/kudu/consensus/leader_election.h               |  4 +-
 src/kudu/consensus/log-test-base.h                 |  7 +--
 src/kudu/consensus/log-test.cc                     |  4 +-
 src/kudu/consensus/log.cc                          |  2 +-
 src/kudu/consensus/log.h                           |  4 +-
 src/kudu/consensus/log_cache-test.cc               |  1 -
 src/kudu/consensus/peer_manager.cc                 | 19 ++++---
 src/kudu/consensus/raft_consensus.cc               |  7 +--
 src/kudu/consensus/raft_consensus.h                |  8 +--
 src/kudu/consensus/raft_consensus_quorum-test.cc   |  6 +-
 src/kudu/consensus/ref_counted_replicate.h         |  9 +--
 src/kudu/gutil/map-util.h                          |  2 +-
 src/kudu/gutil/ref_counted.h                       |  2 +-
 src/kudu/integration-tests/all_types-itest.cc      | 14 ++---
 src/kudu/integration-tests/alter_table-test.cc     | 17 +++---
 .../integration-tests/catalog_manager_tsk-itest.cc |  6 +-
 src/kudu/integration-tests/client-stress-test.cc   |  5 +-
 .../consensus_peer_health_status-itest.cc          |  3 +-
 src/kudu/integration-tests/create-table-itest.cc   | 13 ++---
 src/kudu/integration-tests/decimal-itest.cc        |  9 ++-
 src/kudu/integration-tests/delete_table-itest.cc   |  4 +-
 .../integration-tests/exactly_once_writes-itest.cc |  2 +-
 .../integration-tests/flex_partitioning-itest.cc   |  7 +--
 src/kudu/integration-tests/fuzz-itest.cc           |  5 +-
 src/kudu/integration-tests/linked_list-test.cc     |  5 +-
 .../integration-tests/location_assignment-itest.cc |  1 -
 .../integration-tests/master_replication-itest.cc  |  5 +-
 .../integration-tests/raft_config_change-itest.cc  |  2 +-
 .../integration-tests/raft_consensus-itest-base.cc |  5 +-
 src/kudu/integration-tests/raft_consensus-itest.cc |  4 +-
 .../raft_consensus_election-itest.cc               |  2 +-
 .../raft_consensus_nonvoter-itest.cc               |  2 +-
 .../raft_consensus_stress-itest.cc                 |  3 +-
 src/kudu/integration-tests/registration-test.cc    | 30 +++++-----
 .../integration-tests/security-faults-itest.cc     |  3 +-
 .../security-unknown-tsk-itest.cc                  |  3 +-
 src/kudu/integration-tests/tablet_copy-itest.cc    |  7 ++-
 src/kudu/integration-tests/test_workload.cc        | 43 +++++++--------
 src/kudu/integration-tests/ts_itest-base.cc        |  4 +-
 src/kudu/integration-tests/ts_itest-base.h         |  7 +--
 .../update_scan_delta_compact-test.cc              |  9 ++-
 .../integration-tests/write_throttling-itest.cc    | 32 +++++------
 src/kudu/kserver/kserver.cc                        |  1 -
 src/kudu/master/catalog_manager.cc                 | 12 ++--
 src/kudu/master/master-test.cc                     |  6 +-
 src/kudu/master/sys_catalog-test.cc                |  6 +-
 src/kudu/master/ts_descriptor.h                    |  7 +--
 src/kudu/mini-cluster/internal_mini_cluster.cc     |  8 +--
 src/kudu/rpc/connection.cc                         |  1 -
 src/kudu/rpc/rpc-test.cc                           |  3 +-
 src/kudu/server/glog_metrics.h                     | 10 ++--
 src/kudu/tablet/compaction-test.cc                 | 41 +++++++-------
 src/kudu/tablet/compaction.cc                      | 12 ++--
 src/kudu/tablet/compaction.h                       |  8 +--
 src/kudu/tablet/delta_compaction-test.cc           |  9 ++-
 src/kudu/tablet/delta_compaction.cc                | 23 ++++----
 src/kudu/tablet/delta_compaction.h                 | 12 ++--
 src/kudu/tablet/delta_tracker.cc                   | 12 ++--
 src/kudu/tablet/delta_tracker.h                    |  8 +--
 src/kudu/tablet/deltafile.cc                       |  8 +--
 src/kudu/tablet/deltafile.h                        | 12 ++--
 src/kudu/tablet/deltamemstore-test.cc              |  3 +-
 src/kudu/tablet/deltamemstore.cc                   | 11 ++--
 src/kudu/tablet/deltamemstore.h                    | 10 +---
 src/kudu/tablet/diskrowset-test.cc                 |  1 -
 src/kudu/tablet/diskrowset.cc                      | 25 ++++-----
 src/kudu/tablet/diskrowset.h                       | 47 ++++++++--------
 src/kudu/tablet/local_tablet_writer.h              |  7 +--
 src/kudu/tablet/lock_manager.cc                    | 10 ++--
 src/kudu/tablet/memrowset.cc                       | 17 +++---
 src/kudu/tablet/memrowset.h                        |  7 +--
 src/kudu/tablet/mock-rowsets.h                     |  6 +-
 src/kudu/tablet/multi_column_writer.cc             |  3 +-
 src/kudu/tablet/row_op.cc                          |  5 +-
 src/kudu/tablet/row_op.h                           | 12 ++--
 src/kudu/tablet/rowset.cc                          |  2 +-
 src/kudu/tablet/rowset.h                           |  5 +-
 src/kudu/tablet/rowset_tree.cc                     |  8 ++-
 src/kudu/tablet/rowset_tree.h                      |  8 +--
 src/kudu/tablet/tablet-harness.h                   |  2 +-
 src/kudu/tablet/tablet-test-util.h                 |  3 +-
 src/kudu/tablet/tablet.cc                          | 15 +++--
 src/kudu/tablet/tablet.h                           |  5 +-
 src/kudu/tablet/tablet_bootstrap-test.cc           | 16 +++---
 src/kudu/tablet/tablet_bootstrap.cc                |  1 -
 src/kudu/tablet/tablet_metadata-test.cc            | 11 ++--
 src/kudu/tablet/tablet_metadata.cc                 |  7 +--
 src/kudu/tablet/tablet_metadata.h                  |  5 +-
 src/kudu/tablet/tablet_random_access-test.cc       |  7 +--
 src/kudu/tablet/tablet_replica-test.cc             | 17 +++---
 src/kudu/tablet/tablet_replica.cc                  | 31 +++++------
 src/kudu/tablet/tablet_replica.h                   |  5 +-
 .../transactions/alter_schema_transaction.cc       |  6 +-
 .../tablet/transactions/alter_schema_transaction.h |  6 +-
 src/kudu/tablet/transactions/transaction.h         |  6 +-
 src/kudu/tablet/transactions/transaction_driver.cc |  9 ++-
 src/kudu/tablet/transactions/transaction_driver.h  |  9 ++-
 .../transactions/transaction_tracker-test.cc       | 12 ++--
 src/kudu/tablet/transactions/transaction_tracker.h |  9 +--
 src/kudu/tablet/transactions/write_transaction.cc  |  7 +--
 src/kudu/tablet/transactions/write_transaction.h   |  9 ++-
 src/kudu/tools/ksck_remote-test.cc                 |  7 +--
 src/kudu/tools/ksck_remote.cc                      |  8 +--
 src/kudu/tools/kudu-admin-test.cc                  |  3 +-
 src/kudu/tools/rebalancer_tool-test.cc             |  1 -
 src/kudu/util/bit-stream-utils.h                   | 12 ++--
 src/kudu/util/bit-stream-utils.inline.h            | 15 ++---
 src/kudu/util/rle-encoding.h                       | 19 ++++---
 146 files changed, 679 insertions(+), 818 deletions(-)

diff --git a/docs/design-docs/cpp-client.md b/docs/design-docs/cpp-client.md
index e199adb..7698114 100644
--- a/docs/design-docs/cpp-client.md
+++ b/docs/design-docs/cpp-client.md
@@ -54,12 +54,12 @@ void ExplicitBatchingExample() {
   }
 
   // Update a row.
-  gscoped_ptr<Update> upd = t->NewUpdate();
+  unique_ptr<Update> upd = t->NewUpdate();
   upd->mutable_row()->SetInt64("key", 1);
   upd->mutable_row()->SetInt64("val", 1 * 2 + 1);
 
   // Delete a row.
-  gscoped_ptr<Delete> del = t->NewDelete();
+  unique_ptr<Delete> del = t->NewDelete();
   del->mutable_row()->SetInt64("key", 2); // only specify key.
 
   // Setting a timeout on the session applies to the next Flush call.
@@ -107,7 +107,7 @@ void BulkIngestExample() {
   CHECK_OK(session->SetFlushMode(KuduSession::AUTO_FLUSH_BACKGROUND));
 
   for (int i = 0; i < 10000; i++) {
-    gscoped_ptr<Insertion> ins = t->NewInsertion();
+    unique_ptr<Insertion> ins = t->NewInsertion();
     ins->SetInt64("key", i);
     ins->SetInt64("val", i * 2);
     // This will start getting written in the background.
diff --git a/src/kudu/benchmarks/tpch/rpc_line_item_dao-test.cc b/src/kudu/benchmarks/tpch/rpc_line_item_dao-test.cc
index 9eef222..4ac9c8e 100644
--- a/src/kudu/benchmarks/tpch/rpc_line_item_dao-test.cc
+++ b/src/kudu/benchmarks/tpch/rpc_line_item_dao-test.cc
@@ -15,20 +15,22 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include "kudu/benchmarks/tpch/rpc_line_item_dao.h"
+
 #include <algorithm>
 #include <cstdint>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include <boost/bind.hpp>
+#include <boost/function.hpp>
 #include <glog/logging.h>
 #include <gtest/gtest.h>
 
-#include "kudu/benchmarks/tpch/rpc_line_item_dao.h"
 #include "kudu/benchmarks/tpch/tpch-schemas.h"
 #include "kudu/client/row_result.h"
 #include "kudu/common/partial_row.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/stringprintf.h"
 #include "kudu/master/mini_master.h"
@@ -38,14 +40,15 @@
 #include "kudu/util/test_macros.h"
 #include "kudu/util/test_util.h"
 
-namespace kudu {
-
-using client::KuduRowResult;
-using cluster::InternalMiniCluster;
-using cluster::InternalMiniClusterOptions;
+using kudu::client::KuduRowResult;
+using kudu::cluster::InternalMiniCluster;
+using kudu::cluster::InternalMiniClusterOptions;
 using std::string;
+using std::unique_ptr;
 using std::vector;
 
+namespace kudu {
+
 class RpcLineItemDAOTest : public KuduTest {
 
  public:
@@ -76,8 +79,8 @@ class RpcLineItemDAOTest : public KuduTest {
   }
 
  protected:
-  gscoped_ptr<InternalMiniCluster> cluster_;
-  gscoped_ptr<RpcLineItemDAO> dao_;
+  unique_ptr<InternalMiniCluster> cluster_;
+  unique_ptr<RpcLineItemDAO> dao_;
 
   // Builds a test row to be inserted into the lineitem table.
   // The row's ship_date is set such that it matches the TPCH Q1 predicate.
@@ -107,7 +110,7 @@ class RpcLineItemDAOTest : public KuduTest {
   }
 
   int CountRows() {
-    gscoped_ptr<RpcLineItemDAO::Scanner> scanner;
+    unique_ptr<RpcLineItemDAO::Scanner> scanner;
     dao_->OpenScanner(vector<string>(), &scanner);
     vector<KuduRowResult> rows;
     int count = 0;
@@ -121,7 +124,7 @@ class RpcLineItemDAOTest : public KuduTest {
   void ScanTpch1RangeToStrings(int64_t min_orderkey, int64_t max_orderkey,
                           vector<string>* str_rows) {
     str_rows->clear();
-    gscoped_ptr<RpcLineItemDAO::Scanner> scanner;
+    unique_ptr<RpcLineItemDAO::Scanner> scanner;
     dao_->OpenTpch1ScannerForOrderKeyRange(min_orderkey, max_orderkey,
                                           &scanner);
     vector<KuduRowResult> rows;
@@ -161,7 +164,7 @@ TEST_F(RpcLineItemDAOTest, TestUpdate) {
 
   dao_->MutateLine(boost::bind(UpdateTestRow, 1, 1, 12345, _1));
   dao_->FinishWriting();
-  gscoped_ptr<RpcLineItemDAO::Scanner> scanner;
+  unique_ptr<RpcLineItemDAO::Scanner> scanner;
   dao_->OpenScanner({ tpch::kQuantityColName }, &scanner);
   vector<KuduRowResult> rows;
   while (scanner->HasMore()) {
diff --git a/src/kudu/benchmarks/tpch/rpc_line_item_dao.cc b/src/kudu/benchmarks/tpch/rpc_line_item_dao.cc
index adad044..fd047c4 100644
--- a/src/kudu/benchmarks/tpch/rpc_line_item_dao.cc
+++ b/src/kudu/benchmarks/tpch/rpc_line_item_dao.cc
@@ -17,6 +17,7 @@
 
 #include "kudu/benchmarks/tpch/rpc_line_item_dao.h"
 
+#include <memory>
 #include <ostream>
 #include <vector>
 #include <utility>
@@ -32,7 +33,6 @@
 #include "kudu/client/schema.h"
 #include "kudu/client/value.h"
 #include "kudu/client/write_op.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/util/monotime.h"
@@ -42,29 +42,26 @@
 DEFINE_bool(tpch_cache_blocks_when_scanning, true,
             "Whether the scanners should cache the blocks that are read or not");
 
+using kudu::client::KuduInsert;
+using kudu::client::KuduClientBuilder;
+using kudu::client::KuduError;
+using kudu::client::KuduPredicate;
+using kudu::client::KuduRowResult;
+using kudu::client::KuduScanner;
+using kudu::client::KuduSchema;
+using kudu::client::KuduSession;
+using kudu::client::KuduStatusCallback;
+using kudu::client::KuduTableCreator;
+using kudu::client::KuduUpdate;
+using kudu::client::KuduValue;
 using std::string;
+using std::unique_ptr;
 using std::vector;
 
 namespace kudu {
 
 class KuduPartialRow;
 
-using client::KuduInsert;
-using client::KuduClient;
-using client::KuduClientBuilder;
-using client::KuduError;
-using client::KuduPredicate;
-using client::KuduRowResult;
-using client::KuduScanner;
-using client::KuduSchema;
-using client::KuduSession;
-using client::KuduStatusCallback;
-using client::KuduStatusMemberCallback;
-using client::KuduTableCreator;
-using client::KuduUpdate;
-using client::KuduValue;
-using std::vector;
-
 namespace {
 
 class FlushCallback : public KuduStatusCallback {
@@ -137,7 +134,7 @@ void RpcLineItemDAO::Init() {
            .Build(&client_));
   Status s = client_->OpenTable(table_name_, &client_table_);
   if (s.IsNotFound()) {
-    gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+    unique_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
     table_creator->table_name(table_name_)
         .schema(&schema)
         .num_replicas(1);
@@ -166,14 +163,14 @@ void RpcLineItemDAO::Init() {
 }
 
 void RpcLineItemDAO::WriteLine(const boost::function<void(KuduPartialRow*)> &f) {
-  gscoped_ptr<KuduInsert> insert(client_table_->NewInsert());
+  unique_ptr<KuduInsert> insert(client_table_->NewInsert());
   f(insert->mutable_row());
   CHECK_OK(session_->Apply(insert.release()));
   HandleLine();
 }
 
 void RpcLineItemDAO::MutateLine(const boost::function<void(KuduPartialRow*)> &f) {
-  gscoped_ptr<KuduUpdate> update(client_table_->NewUpdate());
+  unique_ptr<KuduUpdate> update(client_table_->NewUpdate());
   f(update->mutable_row());
   CHECK_OK(session_->Apply(update.release()));
   HandleLine();
@@ -188,12 +185,12 @@ void RpcLineItemDAO::FinishWriting() {
 }
 
 void RpcLineItemDAO::OpenScanner(const vector<string>& columns,
-                                 gscoped_ptr<Scanner>* out_scanner) {
+                                 unique_ptr<Scanner>* out_scanner) {
   vector<KuduPredicate*> preds;
   OpenScannerImpl(columns, preds, out_scanner);
 }
 
-void RpcLineItemDAO::OpenTpch1Scanner(gscoped_ptr<Scanner>* out_scanner) {
+void RpcLineItemDAO::OpenTpch1Scanner(unique_ptr<Scanner>* out_scanner) {
   vector<KuduPredicate*> preds;
   preds.push_back(client_table_->NewComparisonPredicate(
                       tpch::kShipDateColName, KuduPredicate::LESS_EQUAL,
@@ -201,18 +198,18 @@ void RpcLineItemDAO::OpenTpch1Scanner(gscoped_ptr<Scanner>* out_scanner) {
   OpenScannerImpl(tpch::GetTpchQ1QueryColumns(), preds, out_scanner);
 }
 
-void RpcLineItemDAO::OpenTpch1ScannerForOrderKeyRange(int64_t min_key, int64_t max_key,
-                                                      gscoped_ptr<Scanner>* out_scanner) {
+void RpcLineItemDAO::OpenTpch1ScannerForOrderKeyRange(
+    int64_t min_orderkey, int64_t max_orderkey, unique_ptr<Scanner>* out_scanner) {
   vector<KuduPredicate*> preds;
   preds.push_back(client_table_->NewComparisonPredicate(
                       tpch::kShipDateColName, KuduPredicate::LESS_EQUAL,
                       KuduValue::CopyString(kScanUpperBound)));
   preds.push_back(client_table_->NewComparisonPredicate(
                       tpch::kOrderKeyColName, KuduPredicate::GREATER_EQUAL,
-                      KuduValue::FromInt(min_key)));
+                      KuduValue::FromInt(min_orderkey)));
   preds.push_back(client_table_->NewComparisonPredicate(
                       tpch::kOrderKeyColName, KuduPredicate::LESS_EQUAL,
-                      KuduValue::FromInt(max_key)));
+                      KuduValue::FromInt(max_orderkey)));
   OpenScannerImpl(tpch::GetTpchQ1QueryColumns(), preds, out_scanner);
 }
 
@@ -224,8 +221,8 @@ bool RpcLineItemDAO::IsTableEmpty() {
 
 void RpcLineItemDAO::OpenScannerImpl(const vector<string>& columns,
                                      const vector<KuduPredicate*>& preds,
-                                     gscoped_ptr<Scanner>* out_scanner) {
-  gscoped_ptr<Scanner> ret(new Scanner);
+                                     unique_ptr<Scanner>* out_scanner) {
+  unique_ptr<Scanner> ret(new Scanner);
   ret->scanner_.reset(new KuduScanner(client_table_.get()));
   ret->scanner_->SetCacheBlocks(FLAGS_tpch_cache_blocks_when_scanning);
   CHECK_OK(ret->scanner_->SetProjectedColumnNames(columns));
diff --git a/src/kudu/benchmarks/tpch/rpc_line_item_dao.h b/src/kudu/benchmarks/tpch/rpc_line_item_dao.h
index 7f1275f..3205be1 100644
--- a/src/kudu/benchmarks/tpch/rpc_line_item_dao.h
+++ b/src/kudu/benchmarks/tpch/rpc_line_item_dao.h
@@ -14,17 +14,16 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef KUDU_TPCH_RPC_LINE_ITEM_DAO_H
-#define KUDU_TPCH_RPC_LINE_ITEM_DAO_H
+#pragma once
 
 #include <cstdint>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "kudu/client/client.h"
 #include "kudu/client/shared_ptr.h"
 #include "kudu/client/row_result.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/util/locks.h"
 #include "kudu/util/monotime.h"
 #include "kudu/util/semaphore.h"
@@ -67,18 +66,19 @@ class RpcLineItemDAO {
   // Deletes previous scanner if one is open.
   // Projects only those column names listed in 'columns'.
   void OpenScanner(const std::vector<std::string>& columns,
-                   gscoped_ptr<Scanner>* scanner);
+                   std::unique_ptr<Scanner>* scanner);
   // Calls OpenScanner with the tpch1 query parameters.
-  void OpenTpch1Scanner(gscoped_ptr<Scanner>* scanner);
+  void OpenTpch1Scanner(std::unique_ptr<Scanner>* scanner);
 
   // Opens a scanner with the TPCH Q1 projection and filter, plus range filter to only
   // select rows in the given order key range.
   void OpenTpch1ScannerForOrderKeyRange(int64_t min_orderkey, int64_t max_orderkey,
-                                        gscoped_ptr<Scanner>* scanner);
+                                        std::unique_ptr<Scanner>* scanner);
   bool IsTableEmpty();
 
-  // TODO: this wrapper class is of limited utility now that we only have a single
-  // "DAO" implementation -- we could just return the KuduScanner to users directly.
+  // TODO(unknown): this wrapper class is of limited utility now that we only
+  // have a single "DAO" implementation -- we could just return the KuduScanner
+  // to users directly.
   class Scanner {
    public:
     ~Scanner() {}
@@ -93,7 +93,7 @@ class RpcLineItemDAO {
     friend class RpcLineItemDAO;
     Scanner() {}
 
-    gscoped_ptr<client::KuduScanner> scanner_;
+    std::unique_ptr<client::KuduScanner> scanner_;
   };
 
  private:
@@ -101,7 +101,7 @@ class RpcLineItemDAO {
 
   void OpenScannerImpl(const std::vector<std::string>& columns,
                        const std::vector<client::KuduPredicate*>& preds,
-                       gscoped_ptr<Scanner>* scanner);
+                       std::unique_ptr<Scanner>* scanner);
   void HandleLine();
 
   const std::string master_address_;
@@ -124,4 +124,3 @@ class RpcLineItemDAO {
 };
 
 } //namespace kudu
-#endif
diff --git a/src/kudu/benchmarks/tpch/tpch1.cc b/src/kudu/benchmarks/tpch/tpch1.cc
index edd5da9..c4335f2 100644
--- a/src/kudu/benchmarks/tpch/tpch1.cc
+++ b/src/kudu/benchmarks/tpch/tpch1.cc
@@ -59,6 +59,7 @@
 
 #include <cstdint>
 #include <cstdlib>
+#include <memory>
 #include <ostream>
 #include <string>
 #include <unordered_map>
@@ -74,7 +75,6 @@
 #include "kudu/benchmarks/tpch/rpc_line_item_dao.h"
 #include "kudu/client/row_result.h"
 #include "kudu/codegen/compilation_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/hash/city.h"
 #include "kudu/gutil/stringprintf.h"
 #include "kudu/master/mini_master.h"
@@ -104,14 +104,14 @@ DEFINE_int32(tpch_max_batch_size, 1000,
 DEFINE_string(table_name, "lineitem",
               "The table name to write/read");
 
+using kudu::client::KuduRowResult;
 using std::string;
+using std::unique_ptr;
 using std::unordered_map;
 using std::vector;
 
 namespace kudu {
 
-using client::KuduRowResult;
-
 struct Result {
   int32_t l_quantity;
   double l_extendedprice;
@@ -157,7 +157,7 @@ void LoadLineItems(const string &path, RpcLineItemDAO *dao) {
 
 void WarmupScanCache(RpcLineItemDAO* dao) {
   // Warms up cache for the tpch1 query.
-  gscoped_ptr<RpcLineItemDAO::Scanner> scanner;
+  unique_ptr<RpcLineItemDAO::Scanner> scanner;
   dao->OpenTpch1Scanner(&scanner);
   codegen::CompilationManager::GetSingleton()->Wait();
 }
@@ -166,7 +166,7 @@ void Tpch1(RpcLineItemDAO *dao) {
   typedef unordered_map<SliceMapKey, Result*, Hash> slice_map;
   typedef unordered_map<SliceMapKey, slice_map*, Hash> slice_map_map;
 
-  gscoped_ptr<RpcLineItemDAO::Scanner> scanner;
+  unique_ptr<RpcLineItemDAO::Scanner> scanner;
   dao->OpenTpch1Scanner(&scanner);
 
   int matching_rows = 0;
@@ -255,7 +255,7 @@ int main(int argc, char **argv) {
   kudu::InitGoogleLoggingSafe(argv[0]);
 
   kudu::Env* env;
-  gscoped_ptr<kudu::cluster::InternalMiniCluster> cluster;
+  unique_ptr<kudu::cluster::InternalMiniCluster> cluster;
   string master_address;
   if (FLAGS_use_mini_cluster) {
     env = kudu::Env::Default();
@@ -270,7 +270,7 @@ int main(int argc, char **argv) {
     master_address = FLAGS_master_address;
   }
 
-  gscoped_ptr<kudu::RpcLineItemDAO> dao(new kudu::RpcLineItemDAO(
+  unique_ptr<kudu::RpcLineItemDAO> dao(new kudu::RpcLineItemDAO(
       master_address, FLAGS_table_name, FLAGS_tpch_max_batch_size,
       /* timeout_ms = */ 5000, kudu::RpcLineItemDAO::RANGE,
       /* num_buckets = */ 1));
diff --git a/src/kudu/benchmarks/tpch/tpch_real_world.cc b/src/kudu/benchmarks/tpch/tpch_real_world.cc
index f878229..0731516 100644
--- a/src/kudu/benchmarks/tpch/tpch_real_world.cc
+++ b/src/kudu/benchmarks/tpch/tpch_real_world.cc
@@ -47,8 +47,8 @@
 #include <cstdint>
 #include <cstdlib>
 #include <iostream>
+#include <memory>
 #include <string>
-#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -63,7 +63,6 @@
 #include "kudu/client/row_result.h"
 #include "kudu/client/schema.h"
 #include "kudu/common/partial_row.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/stringprintf.h"
@@ -122,17 +121,17 @@ DEFINE_string(tpch_partition_strategy, "range",
               "tablets. This is less ideal, but more faithfully represents a lot of write "
               "workloads.");
 
+using kudu::client::KuduRowResult;
+using kudu::client::KuduSchema;
+using kudu::cluster::ExternalMiniCluster;
+using kudu::cluster::ExternalMiniClusterOptions;
 using std::string;
+using std::unique_ptr;
 using std::vector;
+using strings::Substitute;
 
 namespace kudu {
 
-using client::KuduRowResult;
-using client::KuduSchema;
-using cluster::ExternalMiniCluster;
-using cluster::ExternalMiniClusterOptions;
-using strings::Substitute;
-
 class TpchRealWorld {
  public:
   TpchRealWorld()
@@ -147,7 +146,7 @@ class TpchRealWorld {
 
   Status Init();
 
-  gscoped_ptr<RpcLineItemDAO> GetInittedDAO();
+  unique_ptr<RpcLineItemDAO> GetInittedDAO();
 
   void LoadLineItemsThread(int i);
 
@@ -170,7 +169,7 @@ class TpchRealWorld {
         ? Substitute("$0.$1", kLineItemBase, i + 1) : kLineItemBase;
   }
 
-  gscoped_ptr<ExternalMiniCluster> cluster_;
+  unique_ptr<ExternalMiniCluster> cluster_;
   AtomicInt<int64_t> rows_inserted_;
   string master_addresses_;
   AtomicBool stop_threads_;
@@ -259,7 +258,7 @@ Status TpchRealWorld::StartDbgens() {
       argv.emplace_back("-S");
       argv.push_back(Substitute("$0", i));
     }
-    gscoped_ptr<Subprocess> dbgen_proc(new Subprocess(argv));
+    unique_ptr<Subprocess> dbgen_proc(new Subprocess(argv));
     LOG(INFO) << "Running " << JoinStrings(argv, " ");
     RETURN_NOT_OK(dbgen_proc->Start());
     dbgen_processes_.push_back(dbgen_proc.release());
@@ -267,7 +266,7 @@ Status TpchRealWorld::StartDbgens() {
   return Status::OK();
 }
 
-gscoped_ptr<RpcLineItemDAO> TpchRealWorld::GetInittedDAO() {
+unique_ptr<RpcLineItemDAO> TpchRealWorld::GetInittedDAO() {
   // When chunking, dbgen will begin the nth chunk on the order key:
   //
   //   6000000 * SF * n / num_chunks
@@ -295,7 +294,7 @@ gscoped_ptr<RpcLineItemDAO> TpchRealWorld::GetInittedDAO() {
     LOG(FATAL) << "Unknown partition strategy: " << FLAGS_tpch_partition_strategy;
   }
 
-  gscoped_ptr<RpcLineItemDAO> dao(
+  unique_ptr<RpcLineItemDAO> dao(
         new RpcLineItemDAO(master_addresses_,
                            FLAGS_tpch_table_name,
                            FLAGS_tpch_max_batch_size,
@@ -304,12 +303,12 @@ gscoped_ptr<RpcLineItemDAO> TpchRealWorld::GetInittedDAO() {
                            FLAGS_tpch_num_inserters,
                            split_rows));
   dao->Init();
-  return std::move(dao);
+  return dao;
 }
 
 void TpchRealWorld::LoadLineItemsThread(int i) {
   LOG(INFO) << "Connecting to cluster at " << master_addresses_;
-  gscoped_ptr<RpcLineItemDAO> dao = GetInittedDAO();
+  unique_ptr<RpcLineItemDAO> dao = GetInittedDAO();
   LineItemTsvImporter importer(GetNthLineItemFileName(i));
 
   boost::function<void(KuduPartialRow*)> f =
@@ -359,7 +358,7 @@ void TpchRealWorld::MonitorDbgenThread(int i) {
 }
 
 void TpchRealWorld::RunQueriesThread() {
-  gscoped_ptr<RpcLineItemDAO> dao = GetInittedDAO();
+  unique_ptr<RpcLineItemDAO> dao = GetInittedDAO();
   while (!stop_threads_.Load()) {
     string log;
     if (FLAGS_tpch_load_data) {
@@ -368,7 +367,7 @@ void TpchRealWorld::RunQueriesThread() {
       log = "querying data in cluster";
     }
     LOG_TIMING(INFO, log) {
-      gscoped_ptr<RpcLineItemDAO::Scanner> scanner;
+      unique_ptr<RpcLineItemDAO::Scanner> scanner;
       dao->OpenTpch1Scanner(&scanner);
       vector<KuduRowResult> rows;
       // We check stop_threads_ even while scanning since it can takes tens of seconds to query.
diff --git a/src/kudu/cfile/binary_dict_block.h b/src/kudu/cfile/binary_dict_block.h
index 796f20e..ceb044e 100644
--- a/src/kudu/cfile/binary_dict_block.h
+++ b/src/kudu/cfile/binary_dict_block.h
@@ -31,15 +31,13 @@
 // To use other block builder/decoder, just make sure that BlockDecoder has
 // interface CopyNextValuesToArray(size_t*, uint8_t*). To do that, just replace
 // BShufBuilder/Decoder is ok.
-//
-//
-#ifndef KUDU_CFILE_BINARY_DICT_BLOCK_H
-#define KUDU_CFILE_BINARY_DICT_BLOCK_H
+#pragma once
 
 #include <sys/types.h>
 
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 
 #include <sparsehash/dense_hash_map>
 
@@ -47,7 +45,6 @@
 #include "kudu/cfile/block_encodings.h"
 #include "kudu/cfile/binary_plain_block.h"
 #include "kudu/gutil/casts.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/strings/stringpiece.h"
@@ -114,7 +111,7 @@ class BinaryDictBlockBuilder final : public BlockBuilder {
   bool finished_;
   const WriterOptions* options_;
 
-  gscoped_ptr<BlockBuilder> data_builder_;
+  std::unique_ptr<BlockBuilder> data_builder_;
 
   // dict_block_, dictionary_, dictionary_strings_arena_
   // is related to the dictionary block (one per cfile).
@@ -178,7 +175,7 @@ class BinaryDictBlockDecoder final : public BlockDecoder {
   // Dictionary block decoder
   BinaryPlainBlockDecoder* dict_decoder_;
 
-  gscoped_ptr<BlockDecoder> data_decoder_;
+  std::unique_ptr<BlockDecoder> data_decoder_;
 
   // Parent CFileIterator, each dictionary decoder in the same CFile will share
   // the same vocabulary, and thus, the same set of matching codewords.
@@ -198,5 +195,3 @@ class BinaryDictBlockDecoder final : public BlockDecoder {
 MAKE_ENUM_LIMITS(kudu::cfile::DictEncodingMode,
                  kudu::cfile::DictEncodingMode_min,
                  kudu::cfile::DictEncodingMode_max);
-
-#endif // KUDU_CFILE_BINARY_DICT_BLOCK_H
diff --git a/src/kudu/cfile/block_cache.cc b/src/kudu/cfile/block_cache.cc
index bf93703..ab867dc 100644
--- a/src/kudu/cfile/block_cache.cc
+++ b/src/kudu/cfile/block_cache.cc
@@ -26,7 +26,6 @@
 #include <gflags/gflags.h>
 #include <glog/logging.h>
 
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/util/block_cache_metrics.h"
diff --git a/src/kudu/cfile/block_cache.h b/src/kudu/cfile/block_cache.h
index e7621ec..153b3b2 100644
--- a/src/kudu/cfile/block_cache.h
+++ b/src/kudu/cfile/block_cache.h
@@ -14,15 +14,14 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef KUDU_CFILE_BLOCK_CACHE_H
-#define KUDU_CFILE_BLOCK_CACHE_H
+#pragma once
 
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <utility>
 
 #include "kudu/fs/block_id.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/singleton.h"
@@ -167,7 +166,7 @@ class BlockCache {
 
   DISALLOW_COPY_AND_ASSIGN(BlockCache);
 
-  gscoped_ptr<Cache> cache_;
+  std::unique_ptr<Cache> cache_;
 };
 
 // Scoped reference to a block from the block cache.
@@ -227,5 +226,3 @@ bool ValidateBlockCacheCapacity();
 
 } // namespace cfile
 } // namespace kudu
-
-#endif
diff --git a/src/kudu/cfile/bshuf_block.h b/src/kudu/cfile/bshuf_block.h
index 564db76..eaeb6e0 100644
--- a/src/kudu/cfile/bshuf_block.h
+++ b/src/kudu/cfile/bshuf_block.h
@@ -235,6 +235,7 @@ class BShufBlockDecoder final : public BlockDecoder {
         num_elems_(0),
         compressed_size_(0),
         num_elems_after_padding_(0),
+        size_of_elem_(0),
         cur_idx_(0) {
   }
 
diff --git a/src/kudu/cfile/cfile-test-base.h b/src/kudu/cfile/cfile-test-base.h
index 7f14621..8f3a0bd 100644
--- a/src/kudu/cfile/cfile-test-base.h
+++ b/src/kudu/cfile/cfile-test-base.h
@@ -14,9 +14,7 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-
-#ifndef KUDU_CFILE_TEST_BASE_H
-#define KUDU_CFILE_TEST_BASE_H
+#pragma once
 
 #include <algorithm>
 #include <cstdlib>
@@ -69,8 +67,6 @@ class DataGenerator {
   typedef typename DataTypeTraits<DATA_TYPE>::cpp_type cpp_type;
 
   DataGenerator() :
-    values_(NULL),
-    null_bitmap_(NULL),
     block_entries_(0),
     total_entries_(0)
   {}
@@ -150,8 +146,8 @@ class DataGenerator {
   virtual ~DataGenerator() {}
 
  private:
-  gscoped_array<cpp_type> values_;
-  gscoped_array<uint8_t> null_bitmap_;
+  std::unique_ptr<cpp_type[]> values_;
+  std::unique_ptr<uint8_t[]> null_bitmap_;
   size_t block_entries_;
   size_t total_entries_;
 };
@@ -325,7 +321,7 @@ class DuplicateStringDataGenerator : public DataGenerator<STRING, HAS_NULLS> {
     char data[kItemBufferSize];
   };
 
-  gscoped_array<Buffer> data_buffer_;
+  std::unique_ptr<Buffer[]> data_buffer_;
   const char* format_;
   int num_;
 };
@@ -412,7 +408,7 @@ class CFileTestBase : public KuduTest {
     ASSERT_OK(w.Finish());
   }
 
-  gscoped_ptr<FsManager> fs_manager_;
+  std::unique_ptr<FsManager> fs_manager_;
 
 };
 
@@ -567,5 +563,3 @@ void TimeReadFile(FsManager* fs_manager, const BlockId& block_id, size_t *count_
 
 } // namespace cfile
 } // namespace kudu
-
-#endif
diff --git a/src/kudu/cfile/cfile-test.cc b/src/kudu/cfile/cfile-test.cc
index d8adcf0..c2c3fac 100644
--- a/src/kudu/cfile/cfile-test.cc
+++ b/src/kudu/cfile/cfile-test.cc
@@ -20,6 +20,7 @@
 #include <cstring>
 #include <ctime>
 #include <functional>
+#include <initializer_list>
 #include <memory>
 #include <sstream>
 #include <string>
@@ -27,7 +28,6 @@
 #include <vector>
 
 #include <gflags/gflags.h>
-#include <gflags/gflags_declare.h>
 #include <glog/logging.h>
 #include <gtest/gtest.h>
 
@@ -55,7 +55,6 @@
 #include "kudu/fs/fs_manager.h"
 #include "kudu/fs/io_context.h"
 #include "kudu/gutil/casts.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/singleton.h"
@@ -291,7 +290,7 @@ class TestCFile : public CFileTestBase {
       ASSERT_FALSE(reader->footer().incompatible_features() & IncompatibleFeatures::CHECKSUM);
     }
 
-    gscoped_ptr<IndexTreeIterator> iter;
+    unique_ptr<IndexTreeIterator> iter;
     iter.reset(IndexTreeIterator::Create(nullptr, reader.get(), reader->posidx_root()));
     ASSERT_OK(iter->SeekToFirst());
 
@@ -379,7 +378,7 @@ class TestCFile : public CFileTestBase {
     const fs::IOContext io_context({ "corrupted-dummy-tablet" });
     opts.io_context = &io_context;
     RETURN_NOT_OK(CFileReader::Open(std::move(corrupt_source), std::move(opts), &reader));
-    gscoped_ptr<IndexTreeIterator> iter;
+    unique_ptr<IndexTreeIterator> iter;
     iter.reset(IndexTreeIterator::Create(&io_context, reader.get(), reader->posidx_root()));
     RETURN_NOT_OK(iter->SeekToFirst());
 
@@ -603,7 +602,7 @@ TYPED_TEST(BitShuffleTest, TestFixedSizeReadWriteBitShuffle) {
 }
 
 void EncodeStringKey(const Schema &schema, const Slice& key,
-                     gscoped_ptr<EncodedKey> *encoded_key) {
+                     unique_ptr<EncodedKey> *encoded_key) {
   EncodedKeyBuilder kb(&schema);
   kb.AddColumnKey(&key);
   encoded_key->reset(kb.BuildEncodedKey());
@@ -654,7 +653,7 @@ void TestCFile::TestReadWriteStrings(EncodingType encoding,
   // Now try some seeks by the value instead of position
   /////////
 
-  gscoped_ptr<EncodedKey> encoded_key;
+  unique_ptr<EncodedKey> encoded_key;
   bool exact;
 
   // Seek in between each key.
@@ -1055,7 +1054,7 @@ TEST_P(TestCFileBothCacheMemoryTypes, TestCacheKeysAreStable) {
     unique_ptr<CFileReader> reader;
     ASSERT_OK(CFileReader::Open(std::move(source), ReaderOptions(), &reader));
 
-    gscoped_ptr<IndexTreeIterator> iter;
+    unique_ptr<IndexTreeIterator> iter;
     iter.reset(IndexTreeIterator::Create(nullptr, reader.get(), reader->posidx_root()));
     ASSERT_OK(iter->SeekToFirst());
 
diff --git a/src/kudu/cfile/cfile_reader.cc b/src/kudu/cfile/cfile_reader.cc
index 5ebc193..d044a7e 100644
--- a/src/kudu/cfile/cfile_reader.cc
+++ b/src/kudu/cfile/cfile_reader.cc
@@ -47,7 +47,6 @@
 #include "kudu/fs/error_manager.h"
 #include "kudu/fs/io_context.h"
 #include "kudu/gutil/basictypes.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/stringprintf.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/util/array_view.h"
diff --git a/src/kudu/cfile/cfile_reader.h b/src/kudu/cfile/cfile_reader.h
index 9df42ee..e864dfb 100644
--- a/src/kudu/cfile/cfile_reader.h
+++ b/src/kudu/cfile/cfile_reader.h
@@ -14,9 +14,7 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-
-#ifndef KUDU_CFILE_CFILE_READER_H
-#define KUDU_CFILE_CFILE_READER_H
+#pragma once
 
 #include <cstddef>
 #include <cstdint>
@@ -35,7 +33,6 @@
 #include "kudu/common/rowid.h"
 #include "kudu/fs/block_id.h"
 #include "kudu/fs/block_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/port.h"
 #include "kudu/util/compression/compression.pb.h"
@@ -213,8 +210,8 @@ class CFileReader {
 
   uint8_t cfile_version_;
 
-  gscoped_ptr<CFileHeaderPB> header_;
-  gscoped_ptr<CFileFooterPB> footer_;
+  std::unique_ptr<CFileHeaderPB> header_;
+  std::unique_ptr<CFileFooterPB> footer_;
   const CompressionCodec* codec_;
   const TypeInfo *type_info_;
   const TypeEncodingInfo *type_encoding_info_;
@@ -409,7 +406,7 @@ class CFileIterator : public ColumnIterator {
   struct PreparedBlock {
     BlockPointer dblk_ptr_;
     BlockHandle dblk_data_;
-    gscoped_ptr<BlockDecoder> dblk_;
+    std::unique_ptr<BlockDecoder> dblk_;
 
     // The rowid of the first row in this block.
     rowid_t first_row_idx() const {
@@ -466,11 +463,11 @@ class CFileIterator : public ColumnIterator {
 
   CFileReader* reader_;
 
-  gscoped_ptr<IndexTreeIterator> posidx_iter_;
-  gscoped_ptr<IndexTreeIterator> validx_iter_;
+  std::unique_ptr<IndexTreeIterator> posidx_iter_;
+  std::unique_ptr<IndexTreeIterator> validx_iter_;
 
   // Decoder for the dictionary block.
-  gscoped_ptr<BinaryPlainBlockDecoder> dict_decoder_;
+  std::unique_ptr<BinaryPlainBlockDecoder> dict_decoder_;
   BlockHandle dict_block_handle_;
 
   // Set containing the codewords that match the predicate in a dictionary.
@@ -512,5 +509,3 @@ class CFileIterator : public ColumnIterator {
 
 } // namespace cfile
 } // namespace kudu
-
-#endif
diff --git a/src/kudu/cfile/cfile_writer.h b/src/kudu/cfile/cfile_writer.h
index 9057138..29391bb 100644
--- a/src/kudu/cfile/cfile_writer.h
+++ b/src/kudu/cfile/cfile_writer.h
@@ -14,9 +14,7 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-
-#ifndef KUDU_CFILE_CFILE_WRITER_H
-#define KUDU_CFILE_CFILE_WRITER_H
+#pragma once
 
 #include <cstddef>
 #include <cstdint>
@@ -29,7 +27,6 @@
 #include "kudu/common/rowid.h"
 #include "kudu/fs/block_id.h"
 #include "kudu/fs/block_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/util/bitmap.h"
 #include "kudu/util/compression/compression.pb.h"
@@ -234,11 +231,11 @@ class CFileWriter {
   // Metadata which has been added to the writer but not yet flushed.
   std::vector<std::pair<std::string, std::string> > unflushed_metadata_;
 
-  gscoped_ptr<BlockBuilder> data_block_;
-  gscoped_ptr<IndexTreeBuilder> posidx_builder_;
-  gscoped_ptr<IndexTreeBuilder> validx_builder_;
-  gscoped_ptr<NullBitmapBuilder> null_bitmap_builder_;
-  gscoped_ptr<CompressedBlockBuilder> block_compressor_;
+  std::unique_ptr<BlockBuilder> data_block_;
+  std::unique_ptr<IndexTreeBuilder> posidx_builder_;
+  std::unique_ptr<IndexTreeBuilder> validx_builder_;
+  std::unique_ptr<NullBitmapBuilder> null_bitmap_builder_;
+  std::unique_ptr<CompressedBlockBuilder> block_compressor_;
 
   enum State {
     kWriterInitialized,
@@ -251,5 +248,3 @@ class CFileWriter {
 
 } // namespace cfile
 } // namespace kudu
-
-#endif
diff --git a/src/kudu/cfile/encoding-test.cc b/src/kudu/cfile/encoding-test.cc
index 5d6e3b7..f7eea21 100644
--- a/src/kudu/cfile/encoding-test.cc
+++ b/src/kudu/cfile/encoding-test.cc
@@ -44,13 +44,13 @@
 #include "kudu/common/common.pb.h"
 #include "kudu/common/schema.h"
 #include "kudu/common/types.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/stringprintf.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/util/group_varint-inl.h"
 #include "kudu/util/hexdump.h"
 #include "kudu/util/int128.h"
+#include "kudu/util/int128_util.h"
 #include "kudu/util/memory/arena.h"
 #include "kudu/util/random.h"
 #include "kudu/util/random_util.h"
@@ -125,7 +125,7 @@ class TestEncoding : public KuduTest {
 
   template<class BuilderType, class DecoderType>
   void TestBinarySeekByValueSmallBlock() {
-    gscoped_ptr<WriterOptions> opts(NewWriterOptions());
+    unique_ptr<WriterOptions> opts(NewWriterOptions());
     BuilderType sbb(opts.get());
     // Insert "hello 0" through "hello 9"
     const uint kCount = 10;
@@ -180,7 +180,7 @@ class TestEncoding : public KuduTest {
   template<class BuilderType, class DecoderType>
   void TestStringSeekByValueLargeBlock() {
     Arena arena(1024); // TODO(todd): move to fixture?
-    gscoped_ptr<WriterOptions> opts(NewWriterOptions());
+    unique_ptr<WriterOptions> opts(NewWriterOptions());
     BinaryPrefixBlockBuilder sbb(opts.get());
     const uint kCount = 1000;
     // Insert 'hello 000' through 'hello 999'
@@ -258,7 +258,7 @@ class TestEncoding : public KuduTest {
 
   template<class BuilderType, class DecoderType>
   void TestBinaryBlockRoundTrip() {
-    gscoped_ptr<WriterOptions> opts(NewWriterOptions());
+    unique_ptr<WriterOptions> opts(NewWriterOptions());
     BuilderType sbb(opts.get());
 
     auto seed = SeedRandom();
@@ -398,7 +398,7 @@ class TestEncoding : public KuduTest {
 
   template <class BlockBuilderType, class BlockDecoderType>
   void TestEmptyBlockEncodeDecode() {
-    gscoped_ptr<WriterOptions> opts(NewWriterOptions());
+    unique_ptr<WriterOptions> opts(NewWriterOptions());
     BlockBuilderType bb(opts.get());
     Slice s = bb.Finish(0);
     ASSERT_GT(s.size(), 0);
@@ -412,16 +412,16 @@ class TestEncoding : public KuduTest {
 
   template <DataType Type, class BlockBuilder, class BlockDecoder>
   void TestEncodeDecodeTemplateBlockEncoder(typename TypeTraits<Type>::cpp_type* src,
-                                            uint32_t size) {
+                                            size_t size) {
     typedef typename TypeTraits<Type>::cpp_type CppType;
     const uint32_t kOrdinalPosBase = 12345;
-    gscoped_ptr<WriterOptions> opts(NewWriterOptions());
+    unique_ptr<WriterOptions> opts(NewWriterOptions());
     BlockBuilder pbb(opts.get());
 
     pbb.Add(reinterpret_cast<const uint8_t *>(src), size);
     Slice s = pbb.Finish(kOrdinalPosBase);
 
-    LOG(INFO)<< "Encoded size for 10k elems: " << s.size();
+    LOG(INFO) << "Encoded size for 10k elems: " << s.size();
 
     BlockDecoder pbd(s);
     ASSERT_OK(pbd.ParseHeader());
@@ -448,7 +448,7 @@ class TestEncoding : public KuduTest {
     ASSERT_EQ(0, view.nrows())<< "Should have no space left in the buffer after "
         << "decoding all rows";
 
-    for (uint i = 0; i < size; i++) {
+    for (int i = 0; i < size; i++) {
       if (src[i] != decoded[i]) {
         FAIL()<< "Fail at index " << i <<
             " inserted=" << src[i] << " got=" << decoded[i];
@@ -470,7 +470,7 @@ class TestEncoding : public KuduTest {
   // Test truncation of blocks
   template<class BuilderType, class DecoderType>
   void TestBinaryBlockTruncation() {
-    gscoped_ptr<WriterOptions> opts(NewWriterOptions());
+    unique_ptr<WriterOptions> opts(NewWriterOptions());
     BuilderType sbb(opts.get());
     const uint kCount = 10;
     size_t sbsize;
@@ -682,80 +682,82 @@ class TestEncoding : public KuduTest {
 TEST_F(TestEncoding, TestPlainBlockEncoder) {
   const uint32_t kSize = 10000;
 
-  gscoped_ptr<int32_t[]> ints(new int32_t[kSize]);
+  unique_ptr<int32_t[]> ints(new int32_t[kSize]);
   for (int i = 0; i < kSize; i++) {
     ints.get()[i] = random();
   }
 
   TestEncodeDecodeTemplateBlockEncoder<INT32, PlainBlockBuilder<INT32>,
-                                    PlainBlockDecoder<INT32> >(ints.get(), kSize);
+      PlainBlockDecoder<INT32>>(ints.get(), kSize);
 }
 
 // Test for bitshuffle block, for INT32, INT64, INT128, FLOAT, DOUBLE
 TEST_F(TestEncoding, TestBShufInt32BlockEncoder) {
   const uint32_t kSize = 10000;
 
-  gscoped_ptr<int32_t[]> ints(new int32_t[kSize]);
+  unique_ptr<int32_t[]> ints(new int32_t[kSize]);
   for (int i = 0; i < kSize; i++) {
     ints.get()[i] = random();
   }
 
   TestEncodeDecodeTemplateBlockEncoder<INT32, BShufBlockBuilder<INT32>,
-                                    BShufBlockDecoder<INT32> >(ints.get(), kSize);
+      BShufBlockDecoder<INT32>>(ints.get(), kSize);
 }
 
 TEST_F(TestEncoding, TestBShufInt64BlockEncoder) {
   const uint32_t kSize = 10000;
 
-  gscoped_ptr<int64_t[]> ints(new int64_t[kSize]);
+  unique_ptr<int64_t[]> ints(new int64_t[kSize]);
   for (int i = 0; i < kSize; i++) {
     ints.get()[i] = random();
   }
 
   TestEncodeDecodeTemplateBlockEncoder<INT64, BShufBlockBuilder<INT64>,
-      BShufBlockDecoder<INT64> >(ints.get(), kSize);
+      BShufBlockDecoder<INT64>>(ints.get(), kSize);
 }
 
 TEST_F(TestEncoding, TestBShufInt128BlockEncoder) {
   const uint32_t kSize = 10000;
 
-  gscoped_ptr<int128_t[]> ints(new int128_t[kSize]);
+  unique_ptr<int128_t[]> ints(new int128_t[kSize]);
   for (int i = 0; i < kSize; i++) {
     ints.get()[i] = random();
   }
 
   TestEncodeDecodeTemplateBlockEncoder<INT128, BShufBlockBuilder<INT128>,
-      BShufBlockDecoder<INT128> >(ints.get(), kSize);
+      BShufBlockDecoder<INT128>>(ints.get(), kSize);
 }
 
 TEST_F(TestEncoding, TestBShufFloatBlockEncoder) {
-  const uint32_t kSize = 10000;
+  const int kSize = 10000;
 
-  gscoped_ptr<float[]> floats(new float[kSize]);
+  unique_ptr<float[]> floats(new float[kSize]);
   for (int i = 0; i < kSize; i++) {
-    floats.get()[i] = random() + static_cast<float>(random())/INT_MAX;
+    floats.get()[i] = static_cast<float>(random()) +
+                      static_cast<float>(random())/INT_MAX;
   }
 
   TestEncodeDecodeTemplateBlockEncoder<FLOAT, BShufBlockBuilder<FLOAT>,
-                                    BShufBlockDecoder<FLOAT> >(floats.get(), kSize);
+      BShufBlockDecoder<FLOAT>>(floats.get(), kSize);
 }
 
 TEST_F(TestEncoding, TestBShufDoubleBlockEncoder) {
-  const uint32_t kSize = 10000;
+  const int kSize = 10000;
 
-  gscoped_ptr<double[]> doubles(new double[kSize]);
+  unique_ptr<double[]> doubles(new double[kSize]);
   for (int i = 0; i < kSize; i++) {
-    doubles.get()[i] = random() + + static_cast<double>(random())/INT_MAX;
+    doubles.get()[i] = static_cast<double>(random()) +
+                       static_cast<double>(random())/INT_MAX;
   }
 
   TestEncodeDecodeTemplateBlockEncoder<DOUBLE, BShufBlockBuilder<DOUBLE>,
-                                    BShufBlockDecoder<DOUBLE> >(doubles.get(), kSize);
+      BShufBlockDecoder<DOUBLE>>(doubles.get(), kSize);
 }
 
 TEST_F(TestEncoding, TestRleIntBlockEncoder) {
   unique_ptr<WriterOptions> opts(NewWriterOptions());
   RleIntBlockBuilder<UINT32> ibb(opts.get());
-  gscoped_ptr<int[]> ints(new int[10000]);
+  unique_ptr<int[]> ints(new int[10000]);
   for (int i = 0; i < 10000; i++) {
     ints[i] = random();
   }
@@ -869,8 +871,8 @@ class IntEncodingTest : public TestEncoding {
     typedef typename TestTraits::template Classes<IntType>::encoder_type encoder_type;
     typedef typename TestTraits::template Classes<IntType>::decoder_type decoder_type;
 
-    gscoped_ptr<WriterOptions> opts(NewWriterOptions());
-    gscoped_ptr<encoder_type> ibb(new encoder_type(opts.get()));
+    unique_ptr<WriterOptions> opts(NewWriterOptions());
+    unique_ptr<encoder_type> ibb(new encoder_type(opts.get()));
     DoSeekTest<encoder_type, decoder_type, IntType>(ibb.get(), num_ints, num_queries, verify);
   }
 
@@ -886,8 +888,8 @@ class IntEncodingTest : public TestEncoding {
     typedef typename TestTraits::template Classes<IntType>::encoder_type encoder_type;
     typedef typename TestTraits::template Classes<IntType>::decoder_type decoder_type;
 
-    gscoped_ptr<WriterOptions> opts(NewWriterOptions());
-    gscoped_ptr<encoder_type> ibb(new encoder_type(opts.get()));
+    unique_ptr<WriterOptions> opts(NewWriterOptions());
+    unique_ptr<encoder_type> ibb(new encoder_type(opts.get()));
     TestIntBlockRoundTrip<encoder_type, decoder_type, IntType>(ibb.get());
   }
 };
diff --git a/src/kudu/cfile/index-test.cc b/src/kudu/cfile/index-test.cc
index d1c9b03..7dcee38 100644
--- a/src/kudu/cfile/index-test.cc
+++ b/src/kudu/cfile/index-test.cc
@@ -18,6 +18,7 @@
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
+#include <memory>
 #include <string>
 
 #include <glog/logging.h>
@@ -29,23 +30,25 @@
 #include "kudu/common/common.pb.h"
 #include "kudu/common/key_encoder.h"
 #include "kudu/gutil/endian.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/util/faststring.h"
 #include "kudu/util/hexdump.h"
 #include "kudu/util/slice.h"
 #include "kudu/util/status.h"
 #include "kudu/util/test_macros.h"
 
+using std::string;
+using std::unique_ptr;
+
 namespace kudu {
 namespace cfile {
 
 Status SearchInReaderString(const IndexBlockReader &reader,
-                            const std::string &search_key,
+                            const string &search_key,
                             BlockPointer *ptr, Slice *match) {
 
   static faststring dst;
 
-  gscoped_ptr<IndexBlockIterator> iter(reader.NewIterator());
+  unique_ptr<IndexBlockIterator> iter(reader.NewIterator());
   dst.clear();
   KeyEncoderTraits<BINARY, faststring>::Encode(search_key, &dst);
   Status s = iter->SeekAtOrBefore(Slice(dst));
@@ -63,7 +66,7 @@ Status SearchInReaderUint32(const IndexBlockReader &reader,
 
   static faststring dst;
 
-  gscoped_ptr<IndexBlockIterator> iter(reader.NewIterator());
+  unique_ptr<IndexBlockIterator> iter(reader.NewIterator());
   dst.clear();
   KeyEncoderTraits<UINT32, faststring>::Encode(search_key, &dst);
   Status s = iter->SeekAtOrBefore(Slice(dst));
@@ -310,7 +313,7 @@ TEST(TestIndexBlock, TestIterator) {
 
   IndexBlockReader reader;
   ASSERT_OK(reader.Parse(s));
-  gscoped_ptr<IndexBlockIterator> iter(reader.NewIterator());
+  unique_ptr<IndexBlockIterator> iter(reader.NewIterator());
   ASSERT_OK(iter->SeekToIndex(0));
   ASSERT_EQ(0U, SliceAsUInt32(iter->GetCurrentKey()));
   ASSERT_EQ(100000U, iter->GetCurrentBlockPointer().offset());
diff --git a/src/kudu/client/client.cc b/src/kudu/client/client.cc
index a859a1a..8fdc40b 100644
--- a/src/kudu/client/client.cc
+++ b/src/kudu/client/client.cc
@@ -72,7 +72,6 @@
 #include "kudu/gutil/bind.h"
 #include "kudu/gutil/bind_helpers.h"
 #include "kudu/gutil/casts.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/numbers.h"
@@ -1632,7 +1631,7 @@ void KuduScanner::Close() {
   // to clean up.
   if (!data_->next_req_.scanner_id().empty()) {
     CHECK(data_->proxy_);
-    gscoped_ptr<CloseCallback> closer(new CloseCallback);
+    unique_ptr<CloseCallback> closer(new CloseCallback);
     closer->scanner_id = data_->next_req_.scanner_id();
     data_->PrepareRequest(KuduScanner::Data::CLOSE);
     data_->next_req_.set_close_scanner(true);
diff --git a/src/kudu/client/master_rpc.cc b/src/kudu/client/master_rpc.cc
index f497ead..e82cb20 100644
--- a/src/kudu/client/master_rpc.cc
+++ b/src/kudu/client/master_rpc.cc
@@ -20,6 +20,7 @@
 #include "kudu/client/master_rpc.h"
 
 #include <algorithm>
+#include <memory>
 #include <mutex>
 #include <ostream>
 #include <utility>
@@ -32,7 +33,6 @@
 #include "kudu/consensus/metadata.pb.h"
 #include "kudu/gutil/basictypes.h"
 #include "kudu/gutil/bind.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/strings/join.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/master/master.proxy.h"
@@ -44,11 +44,6 @@
 #include "kudu/util/status.h"
 #include "kudu/util/status_callback.h"
 
-using std::pair;
-using std::shared_ptr;
-using std::string;
-using std::vector;
-
 using kudu::consensus::RaftPeerPB;
 using kudu::master::ConnectToMasterRequestPB;
 using kudu::master::ConnectToMasterResponsePB;
@@ -62,6 +57,11 @@ using kudu::rpc::ErrorStatusPB;
 using kudu::rpc::Messenger;
 using kudu::rpc::Rpc;
 using kudu::rpc::RpcController;
+using std::pair;
+using std::shared_ptr;
+using std::string;
+using std::unique_ptr;
+using std::vector;
 using strings::Substitute;
 
 namespace kudu {
@@ -171,7 +171,7 @@ void ConnectToMasterRpc::SendRpcCb(const Status& status) {
   // will be Status::OK.
   //
   // TODO(todd): this is the most confusing code I've ever seen...
-  gscoped_ptr<ConnectToMasterRpc> deleter(this);
+  unique_ptr<ConnectToMasterRpc> deleter(this);
   Status new_status = status;
 
   rpc::RpcController* rpc = mutable_retrier()->mutable_controller();
diff --git a/src/kudu/client/meta_cache.cc b/src/kudu/client/meta_cache.cc
index a00ff05..531ef76 100644
--- a/src/kudu/client/meta_cache.cc
+++ b/src/kudu/client/meta_cache.cc
@@ -18,6 +18,7 @@
 #include "kudu/client/meta_cache.h"
 
 #include <cstdint>
+#include <memory>
 #include <mutex>
 #include <ostream>
 #include <set>
@@ -40,7 +41,6 @@
 #include "kudu/gutil/bind.h"
 #include "kudu/gutil/bind_helpers.h"
 #include "kudu/gutil/callback.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/stl_util.h"
@@ -57,28 +57,25 @@
 #include "kudu/util/net/sockaddr.h"
 #include "kudu/util/pb_util.h"
 
-using std::map;
+using kudu::consensus::RaftPeerPB;
+using kudu::master::ANY_REPLICA;
+using kudu::master::GetTableLocationsRequestPB;
+using kudu::master::GetTableLocationsResponsePB;
+using kudu::master::MasterServiceProxy;
+using kudu::master::TabletLocationsPB;
+using kudu::master::TSInfoPB;
+using kudu::rpc::BackoffType;
+using kudu::rpc::CredentialsPolicy;
+using kudu::tserver::TabletServerServiceProxy;
 using std::set;
 using std::shared_ptr;
 using std::string;
+using std::unique_ptr;
 using std::vector;
 using strings::Substitute;
 
 namespace kudu {
-
-using consensus::RaftPeerPB;
-using master::ANY_REPLICA;
-using master::GetTableLocationsRequestPB;
-using master::GetTableLocationsResponsePB;
-using master::MasterServiceProxy;
-using master::TabletLocationsPB;
-using master::TSInfoPB;
-using rpc::BackoffType;
-using rpc::CredentialsPolicy;
-using tserver::TabletServerServiceProxy;
-
 namespace client {
-
 namespace internal {
 
 RemoteTabletServer::RemoteTabletServer(const master::TSInfoPB& pb)
@@ -91,7 +88,7 @@ void RemoteTabletServer::DnsResolutionFinished(const HostPort& hp,
                                                KuduClient* client,
                                                const StatusCallback& user_callback,
                                                const Status &result_status) {
-  gscoped_ptr<vector<Sockaddr> > scoped_addrs(addrs);
+  unique_ptr<vector<Sockaddr>> scoped_addrs(addrs);
 
   Status s = result_status;
 
@@ -729,7 +726,7 @@ void LookupRpc::ResetMasterLeaderAndRetry(CredentialsPolicy creds_policy) {
 void LookupRpc::SendRpcCb(const Status& status) {
   // If we exit and haven't scheduled a retry, this object should delete
   // itself.
-  gscoped_ptr<LookupRpc> delete_me(this);
+  unique_ptr<LookupRpc> delete_me(this);
 
   // Check for generic errors.
   Status new_status = status;
diff --git a/src/kudu/client/predicate-test.cc b/src/kudu/client/predicate-test.cc
index 1ed3904..150775a 100644
--- a/src/kudu/client/predicate-test.cc
+++ b/src/kudu/client/predicate-test.cc
@@ -40,7 +40,6 @@
 #include "kudu/client/value.h"
 #include "kudu/client/write_op.h"
 #include "kudu/common/partial_row.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/strings/escaping.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -571,7 +570,7 @@ class PredicateTest : public KuduTest {
   }
 
   shared_ptr<KuduClient> client_;
-  gscoped_ptr<InternalMiniCluster> cluster_;
+  unique_ptr<InternalMiniCluster> cluster_;
 };
 
 TEST_F(PredicateTest, TestBoolPredicates) {
diff --git a/src/kudu/client/scan_predicate.cc b/src/kudu/client/scan_predicate.cc
index de32e99..94abe4c 100644
--- a/src/kudu/client/scan_predicate.cc
+++ b/src/kudu/client/scan_predicate.cc
@@ -32,7 +32,6 @@
 #include "kudu/common/scan_spec.h"
 #include "kudu/common/schema.h"
 #include "kudu/common/types.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/util/block_bloom_filter.h"
diff --git a/src/kudu/client/scan_token-test.cc b/src/kudu/client/scan_token-test.cc
index ebfb160..c247ddc 100644
--- a/src/kudu/client/scan_token-test.cc
+++ b/src/kudu/client/scan_token-test.cc
@@ -42,7 +42,6 @@
 #include "kudu/common/common.pb.h"
 #include "kudu/common/partial_row.h"
 #include "kudu/common/wire_protocol.pb.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/mini-cluster/internal_mini_cluster.h"
 #include "kudu/tserver/mini_tablet_server.h"
@@ -141,7 +140,7 @@ class ScanTokenTest : public KuduTest {
   }
 
   shared_ptr<KuduClient> client_;
-  gscoped_ptr<InternalMiniCluster> cluster_;
+  unique_ptr<InternalMiniCluster> cluster_;
 };
 
 TEST_F(ScanTokenTest, TestScanTokens) {
diff --git a/src/kudu/client/schema.cc b/src/kudu/client/schema.cc
index ebb1eb3..1a9ea4c 100644
--- a/src/kudu/client/schema.cc
+++ b/src/kudu/client/schema.cc
@@ -35,7 +35,6 @@
 #include "kudu/common/schema.h"
 #include "kudu/common/types.h"
 #include "kudu/gutil/casts.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -62,6 +61,7 @@ MAKE_ENUM_LIMITS(kudu::client::KuduColumnSchema::DataType,
                  kudu::client::KuduColumnSchema::BOOL);
 
 using std::string;
+using std::unique_ptr;
 using std::unordered_map;
 using std::vector;
 using strings::Substitute;
@@ -841,10 +841,11 @@ void KuduSchema::CopyFrom(const KuduSchema& other) {
 
 Status KuduSchema::Reset(const vector<KuduColumnSchema>& columns, int key_columns) {
   vector<ColumnSchema> cols_private;
-  for (const KuduColumnSchema& col : columns) {
-    cols_private.push_back(*col.col_);
+  cols_private.reserve(columns.size());
+  for (const auto& col : columns) {
+    cols_private.emplace_back(*col.col_);
   }
-  gscoped_ptr<Schema> new_schema(new Schema());
+  unique_ptr<Schema> new_schema(new Schema());
   RETURN_NOT_OK(new_schema->Reset(cols_private, key_columns));
 
   delete schema_;
diff --git a/src/kudu/client/write_op.cc b/src/kudu/client/write_op.cc
index 83d7e19..5beed13 100644
--- a/src/kudu/client/write_op.cc
+++ b/src/kudu/client/write_op.cc
@@ -17,6 +17,7 @@
 
 #include "kudu/client/write_op.h"
 
+#include <memory>
 #include <ostream>
 
 #include <glog/logging.h>
@@ -29,15 +30,15 @@
 #include "kudu/common/schema.h"
 #include "kudu/common/types.h"
 #include "kudu/common/wire_protocol.pb.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/util/bitmap.h"
 #include "kudu/util/slice.h"
 
+using kudu::client::sp::shared_ptr;
+using std::unique_ptr;
+
 namespace kudu {
 namespace client {
 
-using sp::shared_ptr;
-
 RowOperationsPB_Type ToInternalWriteType(KuduWriteOperation::Type type) {
   switch (type) {
     case KuduWriteOperation::INSERT: return RowOperationsPB_Type_INSERT;
@@ -66,7 +67,7 @@ EncodedKey* KuduWriteOperation::CreateKey() const {
   for (int i = 0; i < row.schema()->num_key_columns(); i++) {
     kb.AddColumnKey(row.cell_ptr(i));
   }
-  gscoped_ptr<EncodedKey> key(kb.BuildEncodedKey());
+  unique_ptr<EncodedKey> key(kb.BuildEncodedKey());
   return key.release();
 }
 
diff --git a/src/kudu/codegen/code_cache.cc b/src/kudu/codegen/code_cache.cc
index 9213a63..deec826 100644
--- a/src/kudu/codegen/code_cache.cc
+++ b/src/kudu/codegen/code_cache.cc
@@ -24,7 +24,6 @@
 #include <glog/logging.h>
 
 #include "kudu/codegen/jit_wrapper.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/util/cache.h"
diff --git a/src/kudu/codegen/code_cache.h b/src/kudu/codegen/code_cache.h
index 0036cf4..c137ef0 100644
--- a/src/kudu/codegen/code_cache.h
+++ b/src/kudu/codegen/code_cache.h
@@ -14,13 +14,11 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-
-#ifndef KUDU_CODEGEN_CODE_CACHE_H
-#define KUDU_CODEGEN_CODE_CACHE_H
+#pragma once
 
 #include <cstddef>
+#include <memory>
 
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/ref_counted.h"
 
@@ -83,13 +81,11 @@ class CodeCache {
  private:
   class EvictionCallback;
 
-  gscoped_ptr<EvictionCallback> eviction_callback_;
-  gscoped_ptr<Cache> cache_;
+  std::unique_ptr<EvictionCallback> eviction_callback_;
+  std::unique_ptr<Cache> cache_;
 
   DISALLOW_COPY_AND_ASSIGN(CodeCache);
 };
 
 } // namespace codegen
 } // namespace kudu
-
-#endif
diff --git a/src/kudu/codegen/code_generator.cc b/src/kudu/codegen/code_generator.cc
index e249d88..7e419ab 100644
--- a/src/kudu/codegen/code_generator.cc
+++ b/src/kudu/codegen/code_generator.cc
@@ -21,6 +21,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <cctype>
+#include <memory>
 #include <sstream>
 #include <string>
 
@@ -40,7 +41,6 @@
 #include <llvm/Target/TargetMachine.h>
 
 #include "kudu/codegen/row_projector.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/once.h"
 #include "kudu/gutil/ref_counted.h"
@@ -78,6 +78,7 @@ using llvm::Target;
 using llvm::TargetMachine;
 using llvm::Triple;
 using std::string;
+using std::unique_ptr;
 
 namespace kudu {
 
@@ -131,7 +132,7 @@ int DumpAsm(FuncPtr fptr, const TargetMachine& tm, std::ostream* out, int max_in
 
   MCContext context(asm_info, register_info, nullptr);
 
-  gscoped_ptr<MCDisassembler> disas(
+  unique_ptr<MCDisassembler> disas(
     CHECK_NOTNULL(tm.getTarget().createMCDisassembler(subtarget_info, context)));
 
   // LLVM uses these completely undocumented magic syntax constants which had
@@ -142,7 +143,7 @@ int DumpAsm(FuncPtr fptr, const TargetMachine& tm, std::ostream* out, int max_in
   // This only has meaning for a *given* target, but at least the 0th syntax
   // will always be defined, so that's what we use.
   static const unsigned kSyntaxVariant = 0;
-  gscoped_ptr<MCInstPrinter> printer(
+  unique_ptr<MCInstPrinter> printer(
     CHECK_NOTNULL(tm.getTarget().createMCInstPrinter(triple, kSyntaxVariant, *asm_info,
                                                      instr_info, *register_info)));
 
diff --git a/src/kudu/codegen/codegen-test.cc b/src/kudu/codegen/codegen-test.cc
index 78f0dd9..76af76a 100644
--- a/src/kudu/codegen/codegen-test.cc
+++ b/src/kudu/codegen/codegen-test.cc
@@ -18,8 +18,10 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <ostream>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include <gflags/gflags_declare.h>
@@ -35,7 +37,6 @@
 #include "kudu/common/row.h"
 #include "kudu/common/rowblock.h"
 #include "kudu/common/schema.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/singleton.h"
 #include "kudu/util/logging_test_util.h"
@@ -48,6 +49,7 @@
 #include "kudu/util/test_util.h"
 
 using std::string;
+using std::unique_ptr;
 using std::vector;
 
 DECLARE_bool(codegen_dump_mc);
@@ -114,7 +116,7 @@ class CodegenTest : public KuduTest {
   template<bool READ>
   void TestProjection(const Schema* proj);
   // Generates a new row projector for the given projection schema.
-  Status Generate(const Schema* proj, gscoped_ptr<CodegenRP>* out);
+  Status Generate(const Schema* proj, unique_ptr<CodegenRP>* out);
 
   enum {
     // Base schema column indices
@@ -151,9 +153,9 @@ class CodegenTest : public KuduTest {
 
   codegen::CodeGenerator generator_;
   Random random_;
-  gscoped_ptr<ConstContiguousRow> test_rows_[kNumTestRows];
+  unique_ptr<ConstContiguousRow> test_rows_[kNumTestRows];
   Arena projections_arena_;
-  gscoped_ptr<Arena> test_rows_arena_;
+  unique_ptr<Arena> test_rows_arena_;
 };
 
 namespace {
@@ -211,7 +213,7 @@ void CodegenTest::ProjectTestRows(RowProjectorType* rp, RowBlock* rb) {
 
 template<bool READ>
 void CodegenTest::TestProjection(const Schema* proj) {
-  gscoped_ptr<CodegenRP> with;
+  unique_ptr<CodegenRP> with;
   ASSERT_OK(Generate(proj, &with));
   NoCodegenRP without(&base_, proj);
   ASSERT_OK(without.Init());
@@ -228,7 +230,7 @@ void CodegenTest::TestProjection(const Schema* proj) {
   CheckRowBlocksEqual(&rb_with, &rb_without, "Codegen", "Expected");
 }
 
-Status CodegenTest::Generate(const Schema* proj, gscoped_ptr<CodegenRP>* out) {
+Status CodegenTest::Generate(const Schema* proj, unique_ptr<CodegenRP>* out) {
   scoped_refptr<codegen::RowProjectorFunctions> functions;
   RETURN_NOT_OK(generator_.CompileRowProjector(base_, *proj, &functions));
   out->reset(new CodegenRP(&base_, proj, functions));
@@ -247,7 +249,7 @@ Status CodegenTest::CreatePartialSchema(const vector<size_t>& col_indexes,
 TEST_F(CodegenTest, ObservablesTest) {
   // Test when not identity
   Schema proj = base_.CreateKeyProjection();
-  gscoped_ptr<CodegenRP> with;
+  unique_ptr<CodegenRP> with;
   CHECK_OK(Generate(&proj, &with));
   NoCodegenRP without(&base_, &proj);
   ASSERT_OK(without.Init());
@@ -258,7 +260,7 @@ TEST_F(CodegenTest, ObservablesTest) {
 
   // Test when identity
   Schema iproj = *&base_;
-  gscoped_ptr<CodegenRP> iwith;
+  unique_ptr<CodegenRP> iwith;
   CHECK_OK(Generate(&iproj, &iwith));
   NoCodegenRP iwithout(&base_, &iproj);
   ASSERT_OK(iwithout.Init());
@@ -401,7 +403,7 @@ TEST_F(CodegenTest, TestCodeCache) {
       Schema projection;
       ASSERT_OK(CreatePartialSchema(perm, &projection));
 
-      gscoped_ptr<CodegenRP> projector;
+      unique_ptr<CodegenRP> projector;
       if (cm->RequestRowProjector(&base_, &projection, &projector)) {
         num_hits++;
       }
diff --git a/src/kudu/codegen/compilation_manager.cc b/src/kudu/codegen/compilation_manager.cc
index 51263d6..2e45be4 100644
--- a/src/kudu/codegen/compilation_manager.cc
+++ b/src/kudu/codegen/compilation_manager.cc
@@ -34,7 +34,6 @@
 #include "kudu/gutil/bind_helpers.h"
 #include "kudu/gutil/callback.h"
 #include "kudu/gutil/casts.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/util/faststring.h"
 #include "kudu/util/flag_tags.h"
@@ -46,6 +45,7 @@
 #include "kudu/util/threadpool.h"
 
 using std::shared_ptr;
+using std::unique_ptr;
 
 DEFINE_bool(codegen_time_compilation, false, "Whether to print time that each code "
             "generation request took.");
@@ -176,7 +176,7 @@ Status CompilationManager::StartInstrumentation(const scoped_refptr<MetricEntity
 
 bool CompilationManager::RequestRowProjector(const Schema* base_schema,
                                              const Schema* projection,
-                                             gscoped_ptr<RowProjector>* out) {
+                                             unique_ptr<RowProjector>* out) {
   faststring key;
   Status s = RowProjectorFunctions::EncodeKey(*base_schema, *projection, &key);
   WARN_NOT_OK(s, "RowProjector compilation request failed");
diff --git a/src/kudu/codegen/compilation_manager.h b/src/kudu/codegen/compilation_manager.h
index 4cca427..7aa05df 100644
--- a/src/kudu/codegen/compilation_manager.h
+++ b/src/kudu/codegen/compilation_manager.h
@@ -21,7 +21,6 @@
 
 #include "kudu/codegen/code_generator.h"
 #include "kudu/codegen/code_cache.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/singleton.h"
@@ -75,7 +74,7 @@ class CompilationManager {
   // Does not write to 'out' if false is returned.
   bool RequestRowProjector(const Schema* base_schema,
                            const Schema* projection,
-                           gscoped_ptr<RowProjector>* out);
+                           std::unique_ptr<RowProjector>* out);
 
   // Waits for all asynchronous compilation tasks to finish.
   void Wait();
diff --git a/src/kudu/consensus/consensus-test-util.h b/src/kudu/consensus/consensus-test-util.h
index a315028..65fd16e 100644
--- a/src/kudu/consensus/consensus-test-util.h
+++ b/src/kudu/consensus/consensus-test-util.h
@@ -63,11 +63,11 @@
 namespace kudu {
 namespace consensus {
 
-inline gscoped_ptr<ReplicateMsg> CreateDummyReplicate(int64_t term,
-                                                      int64_t index,
-                                                      const Timestamp& timestamp,
-                                                      int64_t payload_size) {
-    gscoped_ptr<ReplicateMsg> msg(new ReplicateMsg);
+inline std::unique_ptr<ReplicateMsg> CreateDummyReplicate(int64_t term,
+                                                          int64_t index,
+                                                          const Timestamp& timestamp,
+                                                          int64_t payload_size) {
+    std::unique_ptr<ReplicateMsg> msg(new ReplicateMsg);
     OpId* id = msg->mutable_id();
     id->set_term(term);
     id->set_index(index);
@@ -75,7 +75,7 @@ inline gscoped_ptr<ReplicateMsg> CreateDummyReplicate(int64_t term,
     msg->set_op_type(NO_OP);
     msg->mutable_noop_request()->mutable_payload_for_tests()->resize(payload_size);
     msg->set_timestamp(timestamp.ToUint64());
-    return std::move(msg);
+    return msg;
 }
 
 // Returns RaftPeerPB with given UUID and obviously-fake hostname / port combo.
@@ -250,7 +250,7 @@ class DelayablePeerProxy : public TestPeerProxy {
   }
 
  protected:
-  gscoped_ptr<ProxyType> const proxy_;
+  std::unique_ptr<ProxyType> const proxy_;
   bool delay_response_; // Protected by lock_.
   CountDownLatch latch_;
 };
@@ -392,7 +392,7 @@ class NoOpTestPeerProxyFactory : public PeerProxyFactory {
   }
 
   Status NewProxy(const consensus::RaftPeerPB& peer_pb,
-                  gscoped_ptr<PeerProxy>* proxy) override {
+                  std::unique_ptr<PeerProxy>* proxy) override {
     proxy->reset(new NoOpTestPeerProxy(pool_.get(), peer_pb));
     return Status::OK();
   }
@@ -613,7 +613,7 @@ class LocalTestPeerProxyFactory : public PeerProxyFactory {
   }
 
   Status NewProxy(const consensus::RaftPeerPB& peer_pb,
-                  gscoped_ptr<PeerProxy>* proxy) override {
+                  std::unique_ptr<PeerProxy>* proxy) override {
     LocalTestPeerProxy* new_proxy = new LocalTestPeerProxy(peer_pb.permanent_uuid(),
                                                            pool_.get(),
                                                            peers_);
@@ -676,7 +676,7 @@ class TestDriver {
   // The commit message has the exact same type of the replicate message, but
   // no content.
   void Apply() {
-    gscoped_ptr<CommitMsg> msg(new CommitMsg);
+    std::unique_ptr<CommitMsg> msg(new CommitMsg);
     msg->set_op_type(round_->replicate_msg()->op_type());
     msg->mutable_commited_op_id()->CopyFrom(round_->id());
     CHECK_OK(log_->AsyncAppendCommit(std::move(msg),
diff --git a/src/kudu/consensus/consensus_peers-test.cc b/src/kudu/consensus/consensus_peers-test.cc
index 4a73948..81ec3b5 100644
--- a/src/kudu/consensus/consensus_peers-test.cc
+++ b/src/kudu/consensus/consensus_peers-test.cc
@@ -19,7 +19,6 @@
 
 #include <memory>
 #include <string>
-#include <type_traits>
 #include <utility>
 
 #include <glog/logging.h>
@@ -41,7 +40,6 @@
 #include "kudu/consensus/opid_util.h"
 #include "kudu/consensus/time_manager.h"
 #include "kudu/fs/fs_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/rpc/messenger.h"
@@ -138,7 +136,7 @@ class ConsensusPeersTest : public KuduTest {
     peer_pb.set_member_type(RaftPeerPB::VOTER);
     auto proxy_ptr = new DelayablePeerProxy<NoOpTestPeerProxy>(
         raft_pool_.get(), new NoOpTestPeerProxy(raft_pool_.get(), peer_pb));
-    gscoped_ptr<PeerProxy> proxy(proxy_ptr);
+    unique_ptr<PeerProxy> proxy(proxy_ptr);
     CHECK_OK(Peer::NewRemotePeer(std::move(peer_pb),
                                  kTabletId,
                                  kLeaderUuid,
@@ -283,7 +281,7 @@ TEST_F(ConsensusPeersTest, TestCloseWhenRemotePeerDoesntMakeProgress) {
                                 kLeaderUuid,
                                 message_queue_.get(),
                                 raft_pool_token_.get(),
-                                gscoped_ptr<PeerProxy>(mock_proxy),
+                                unique_ptr<PeerProxy>(mock_proxy),
                                 messenger_,
                                 &peer));
 
@@ -321,7 +319,7 @@ TEST_F(ConsensusPeersTest, TestDontSendOneRpcPerWriteWhenPeerIsDown) {
                                 kLeaderUuid,
                                 message_queue_.get(),
                                 raft_pool_token_.get(),
-                                gscoped_ptr<PeerProxy>(mock_proxy),
+                                unique_ptr<PeerProxy>(mock_proxy),
                                 messenger_,
                                 &peer));
 
diff --git a/src/kudu/consensus/consensus_peers.cc b/src/kudu/consensus/consensus_peers.cc
index 554ff4d..d759ca1 100644
--- a/src/kudu/consensus/consensus_peers.cc
+++ b/src/kudu/consensus/consensus_peers.cc
@@ -23,7 +23,6 @@
 #include <mutex>
 #include <ostream>
 #include <string>
-#include <type_traits>
 #include <vector>
 
 #include <gflags/gflags.h>
@@ -37,7 +36,6 @@
 #include "kudu/consensus/consensus_queue.h"
 #include "kudu/consensus/metadata.pb.h"
 #include "kudu/consensus/opid_util.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -109,7 +107,7 @@ Status Peer::NewRemotePeer(RaftPeerPB peer_pb,
                            string leader_uuid,
                            PeerMessageQueue* queue,
                            ThreadPoolToken* raft_pool_token,
-                           gscoped_ptr<PeerProxy> proxy,
+                           unique_ptr<PeerProxy> proxy,
                            shared_ptr<Messenger> messenger,
                            shared_ptr<Peer>* peer) {
 
@@ -130,7 +128,7 @@ Peer::Peer(RaftPeerPB peer_pb,
            string leader_uuid,
            PeerMessageQueue* queue,
            ThreadPoolToken* raft_pool_token,
-           gscoped_ptr<PeerProxy> proxy,
+           unique_ptr<PeerProxy> proxy,
            shared_ptr<Messenger> messenger)
     : tablet_id_(std::move(tablet_id)),
       leader_uuid_(std::move(leader_uuid)),
@@ -510,7 +508,7 @@ Peer::~Peer() {
 }
 
 RpcPeerProxy::RpcPeerProxy(HostPort hostport,
-                           gscoped_ptr<ConsensusServiceProxy> consensus_proxy)
+                           unique_ptr<ConsensusServiceProxy> consensus_proxy)
     : hostport_(std::move(hostport)),
       consensus_proxy_(std::move(DCHECK_NOTNULL(consensus_proxy))) {
 }
@@ -556,7 +554,7 @@ Status CreateConsensusServiceProxyForHost(
     const HostPort& hostport,
     const shared_ptr<Messenger>& messenger,
     DnsResolver* dns_resolver,
-    gscoped_ptr<ConsensusServiceProxy>* new_proxy) {
+    unique_ptr<ConsensusServiceProxy>* new_proxy) {
   vector<Sockaddr> addrs;
   RETURN_NOT_OK(dns_resolver->ResolveAddresses(hostport, &addrs));
   if (addrs.size() > 1) {
@@ -577,10 +575,10 @@ RpcPeerProxyFactory::RpcPeerProxyFactory(shared_ptr<Messenger> messenger,
 }
 
 Status RpcPeerProxyFactory::NewProxy(const RaftPeerPB& peer_pb,
-                                     gscoped_ptr<PeerProxy>* proxy) {
+                                     unique_ptr<PeerProxy>* proxy) {
   HostPort hostport;
   RETURN_NOT_OK(HostPortFromPB(peer_pb.last_known_addr(), &hostport));
-  gscoped_ptr<ConsensusServiceProxy> new_proxy;
+  unique_ptr<ConsensusServiceProxy> new_proxy;
   RETURN_NOT_OK(CreateConsensusServiceProxyForHost(
       hostport, messenger_, dns_resolver_, &new_proxy));
   proxy->reset(new RpcPeerProxy(std::move(hostport), std::move(new_proxy)));
@@ -594,7 +592,7 @@ Status SetPermanentUuidForRemotePeer(
   DCHECK(!remote_peer->has_permanent_uuid());
   HostPort hostport;
   RETURN_NOT_OK(HostPortFromPB(remote_peer->last_known_addr(), &hostport));
-  gscoped_ptr<ConsensusServiceProxy> proxy;
+  unique_ptr<ConsensusServiceProxy> proxy;
   RETURN_NOT_OK(CreateConsensusServiceProxyForHost(
       hostport, messenger, resolver, &proxy));
   GetNodeInstanceRequestPB req;
diff --git a/src/kudu/consensus/consensus_peers.h b/src/kudu/consensus/consensus_peers.h
index 0b4f24b..887b147 100644
--- a/src/kudu/consensus/consensus_peers.h
+++ b/src/kudu/consensus/consensus_peers.h
@@ -14,9 +14,7 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-
-#ifndef KUDU_CONSENSUS_CONSENSUS_PEERS_H_
-#define KUDU_CONSENSUS_CONSENSUS_PEERS_H_
+#pragma once
 
 #include <cstdint>
 #include <memory>
@@ -30,7 +28,6 @@
 #include "kudu/consensus/consensus.proxy.h"
 #include "kudu/consensus/metadata.pb.h"
 #include "kudu/consensus/ref_counted_replicate.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/rpc/response_callback.h"
 #include "kudu/rpc/rpc_controller.h"
 #include "kudu/util/locks.h"
@@ -114,7 +111,7 @@ class Peer : public std::enable_shared_from_this<Peer> {
                               std::string leader_uuid,
                               PeerMessageQueue* queue,
                               ThreadPoolToken* raft_pool_token,
-                              gscoped_ptr<PeerProxy> proxy,
+                              std::unique_ptr<PeerProxy> proxy,
                               std::shared_ptr<rpc::Messenger> messenger,
                               std::shared_ptr<Peer>* peer);
 
@@ -124,7 +121,7 @@ class Peer : public std::enable_shared_from_this<Peer> {
        std::string leader_uuid,
        PeerMessageQueue* queue,
        ThreadPoolToken* raft_pool_token,
-       gscoped_ptr<PeerProxy> proxy,
+       std::unique_ptr<PeerProxy> proxy,
        std::shared_ptr<rpc::Messenger> messenger);
 
   void SendNextRequest(bool even_if_queue_empty);
@@ -161,7 +158,7 @@ class Peer : public std::enable_shared_from_this<Peer> {
 
   RaftPeerPB peer_pb_;
 
-  gscoped_ptr<PeerProxy> proxy_;
+  std::unique_ptr<PeerProxy> proxy_;
 
   PeerMessageQueue* queue_;
   uint64_t failed_attempts_;
@@ -241,7 +238,7 @@ class PeerProxyFactory {
  public:
 
   virtual Status NewProxy(const RaftPeerPB& peer_pb,
-                          gscoped_ptr<PeerProxy>* proxy) = 0;
+                          std::unique_ptr<PeerProxy>* proxy) = 0;
 
   virtual ~PeerProxyFactory() {}
 
@@ -252,7 +249,7 @@ class PeerProxyFactory {
 class RpcPeerProxy : public PeerProxy {
  public:
   RpcPeerProxy(HostPort hostport,
-               gscoped_ptr<ConsensusServiceProxy> consensus_proxy);
+               std::unique_ptr<ConsensusServiceProxy> consensus_proxy);
 
   void UpdateAsync(const ConsensusRequestPB& request,
                    ConsensusResponsePB* response,
@@ -278,7 +275,7 @@ class RpcPeerProxy : public PeerProxy {
 
  private:
   const HostPort hostport_;
-  gscoped_ptr<ConsensusServiceProxy> consensus_proxy_;
+  std::unique_ptr<ConsensusServiceProxy> consensus_proxy_;
 };
 
 // PeerProxyFactory implementation that generates RPCPeerProxies
@@ -289,7 +286,7 @@ class RpcPeerProxyFactory : public PeerProxyFactory {
   ~RpcPeerProxyFactory() = default;
 
   Status NewProxy(const RaftPeerPB& peer_pb,
-                  gscoped_ptr<PeerProxy>* proxy) override;
+                  std::unique_ptr<PeerProxy>* proxy) override;
 
   const std::shared_ptr<rpc::Messenger>& messenger() const override {
     return messenger_;
@@ -310,5 +307,3 @@ Status SetPermanentUuidForRemotePeer(
 
 }  // namespace consensus
 }  // namespace kudu
-
-#endif /* KUDU_CONSENSUS_CONSENSUS_PEERS_H_ */
diff --git a/src/kudu/consensus/consensus_queue-test.cc b/src/kudu/consensus/consensus_queue-test.cc
index b77c8db..c929c1d 100644
--- a/src/kudu/consensus/consensus_queue-test.cc
+++ b/src/kudu/consensus/consensus_queue-test.cc
@@ -51,7 +51,6 @@
 #include "kudu/consensus/ref_counted_replicate.h"
 #include "kudu/consensus/time_manager.h"
 #include "kudu/fs/fs_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/util/async_util.h"
@@ -240,11 +239,11 @@ class ConsensusQueueTest : public KuduTest {
   MetricRegistry metric_registry_;
   scoped_refptr<MetricEntity> metric_entity_server_;
   scoped_refptr<MetricEntity> metric_entity_tablet_;
-  gscoped_ptr<FsManager> fs_manager_;
+  unique_ptr<FsManager> fs_manager_;
   scoped_refptr<log::Log> log_;
   unique_ptr<ThreadPool> raft_pool_;
   unique_ptr<TimeManager> time_manager_;
-  gscoped_ptr<PeerMessageQueue> queue_;
+  unique_ptr<PeerMessageQueue> queue_;
   scoped_refptr<log::LogAnchorRegistry> registry_;
   unique_ptr<clock::Clock> clock_;
   atomic<bool> quiescing_;
diff --git a/src/kudu/consensus/consensus_queue.h b/src/kudu/consensus/consensus_queue.h
index def0ba3..384f3a5 100644
--- a/src/kudu/consensus/consensus_queue.h
+++ b/src/kudu/consensus/consensus_queue.h
@@ -33,7 +33,6 @@
 #include "kudu/consensus/metadata.pb.h"
 #include "kudu/consensus/opid.pb.h"
 #include "kudu/consensus/ref_counted_replicate.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/threading/thread_collision_warner.h"
 #include "kudu/util/locks.h"
@@ -438,7 +437,7 @@ class PeerMessageQueue {
     Mode mode;
 
     // The currently-active raft config. Only set if in LEADER mode.
-    gscoped_ptr<RaftConfigPB> active_config;
+    std::unique_ptr<RaftConfigPB> active_config;
 
     std::string ToString() const;
   };
diff --git a/src/kudu/consensus/leader_election-test.cc b/src/kudu/consensus/leader_election-test.cc
index e6e601c..101ec13 100644
--- a/src/kudu/consensus/leader_election-test.cc
+++ b/src/kudu/consensus/leader_election-test.cc
@@ -35,7 +35,6 @@
 #include "kudu/consensus/metadata.pb.h"
 #include "kudu/consensus/raft_consensus.h"
 #include "kudu/gutil/casts.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/stl_util.h"
@@ -92,7 +91,7 @@ class FromMapPeerProxyFactory : public PeerProxyFactory {
   }
 
   Status NewProxy(const RaftPeerPB& peer_pb,
-                  gscoped_ptr<PeerProxy>* proxy) override {
+                  unique_ptr<PeerProxy>* proxy) override {
     PeerProxy* proxy_ptr = FindPtrOrNull(*proxy_map_, peer_pb.permanent_uuid());
     if (!proxy_ptr) return Status::NotFound("no proxy for peer");
     proxy->reset(proxy_ptr);
@@ -146,11 +145,11 @@ class LeaderElectionTest : public KuduTest {
 
   RaftConfigPB config_;
   ProxyMap proxies_;
-  gscoped_ptr<PeerProxyFactory> proxy_factory_;
+  unique_ptr<PeerProxyFactory> proxy_factory_;
   unique_ptr<ThreadPool> pool_;
 
   CountDownLatch latch_;
-  gscoped_ptr<ElectionResult> result_;
+  unique_ptr<ElectionResult> result_;
 };
 
 void LeaderElectionTest::ElectionCallback(const ElectionResult& result) {
diff --git a/src/kudu/consensus/leader_election.h b/src/kudu/consensus/leader_election.h
index c42e7c6..c7fe8f8 100644
--- a/src/kudu/consensus/leader_election.h
+++ b/src/kudu/consensus/leader_election.h
@@ -14,7 +14,6 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-
 #pragma once
 
 #include <cstdint>
@@ -28,7 +27,6 @@
 #include "kudu/consensus/consensus_peers.h"
 #include "kudu/consensus/metadata.pb.h"
 #include "kudu/consensus/raft_consensus.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/rpc/rpc_controller.h"
@@ -162,7 +160,7 @@ class LeaderElection : public RefCountedThreadSafe<LeaderElection> {
 
   struct VoterState {
     std::string peer_uuid;
-    gscoped_ptr<PeerProxy> proxy;
+    std::unique_ptr<PeerProxy> proxy;
 
     // If constructing the proxy failed (e.g. due to a DNS resolution issue)
     // then 'proxy' will be NULL, and 'proxy_status' will contain the error.
diff --git a/src/kudu/consensus/log-test-base.h b/src/kudu/consensus/log-test-base.h
index 1ae43ae..b7728bd 100644
--- a/src/kudu/consensus/log-test-base.h
+++ b/src/kudu/consensus/log-test-base.h
@@ -36,7 +36,6 @@
 #include "kudu/consensus/metadata.pb.h"
 #include "kudu/consensus/opid_util.h"
 #include "kudu/fs/fs_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/stringprintf.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -279,7 +278,7 @@ class LogTestBase : public KuduTest {
                       int rs_id,
                       int dms_id,
                       bool sync = APPEND_SYNC) {
-    gscoped_ptr<consensus::CommitMsg> commit(new consensus::CommitMsg);
+    std::unique_ptr<consensus::CommitMsg> commit(new consensus::CommitMsg);
     commit->set_op_type(consensus::WRITE_OP);
 
     commit->mutable_commited_op_id()->CopyFrom(original_opid);
@@ -300,7 +299,7 @@ class LogTestBase : public KuduTest {
   // indicating that the associated writes failed due to
   // "NotFound" errors.
   Status AppendCommitWithNotFoundOpResults(const consensus::OpId& original_opid) {
-    gscoped_ptr<consensus::CommitMsg> commit(new consensus::CommitMsg);
+    std::unique_ptr<consensus::CommitMsg> commit(new consensus::CommitMsg);
     commit->set_op_type(consensus::WRITE_OP);
     commit->mutable_commited_op_id()->CopyFrom(original_opid);
 
@@ -314,7 +313,7 @@ class LogTestBase : public KuduTest {
     return AppendCommit(std::move(commit));
   }
 
-  Status AppendCommit(gscoped_ptr<consensus::CommitMsg> commit,
+  Status AppendCommit(std::unique_ptr<consensus::CommitMsg> commit,
                       bool sync = APPEND_SYNC) {
     if (sync) {
       Synchronizer s;
diff --git a/src/kudu/consensus/log-test.cc b/src/kudu/consensus/log-test.cc
index 3800554..f3f2b2f 100644
--- a/src/kudu/consensus/log-test.cc
+++ b/src/kudu/consensus/log-test.cc
@@ -24,7 +24,6 @@
 #include <memory>
 #include <ostream>
 #include <string>
-#include <type_traits>
 #include <vector>
 
 #include <gflags/gflags.h>
@@ -43,7 +42,6 @@
 #include "kudu/consensus/log_util.h"
 #include "kudu/consensus/opid.pb.h"
 #include "kudu/consensus/opid_util.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -928,7 +926,7 @@ void LogTest::AppendTestSequence(const vector<TestLogSequenceElem>& seq) {
       }
       case TestLogSequenceElem::COMMIT:
       {
-        gscoped_ptr<CommitMsg> commit(new CommitMsg);
+        unique_ptr<CommitMsg> commit(new CommitMsg);
         commit->set_op_type(NO_OP);
         commit->mutable_commited_op_id()->CopyFrom(e.id);
         Synchronizer s;
diff --git a/src/kudu/consensus/log.cc b/src/kudu/consensus/log.cc
index ed6057a..48e4be6 100644
--- a/src/kudu/consensus/log.cc
+++ b/src/kudu/consensus/log.cc
@@ -875,7 +875,7 @@ Status Log::AsyncAppendReplicates(const vector<ReplicateRefPtr>& replicates,
   return AsyncAppend(std::move(batch), callback);
 }
 
-Status Log::AsyncAppendCommit(gscoped_ptr<consensus::CommitMsg> commit_msg,
+Status Log::AsyncAppendCommit(unique_ptr<consensus::CommitMsg> commit_msg,
                               const StatusCallback& callback) {
   MAYBE_FAULT(FLAGS_fault_crash_before_append_commit);
 
diff --git a/src/kudu/consensus/log.h b/src/kudu/consensus/log.h
index cd2907b..ceeba63 100644
--- a/src/kudu/consensus/log.h
+++ b/src/kudu/consensus/log.h
@@ -37,7 +37,6 @@
 #include "kudu/consensus/opid.pb.h"
 #include "kudu/consensus/ref_counted_replicate.h"
 #include "kudu/gutil/callback.h"  // IWYU pragma: keep
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/util/blocking_queue.h"
@@ -302,10 +301,9 @@ class Log : public RefCountedThreadSafe<Log> {
   // Append the given commit message, asynchronously.
   //
   // Returns a bad status if the log is already shut down.
-  Status AsyncAppendCommit(gscoped_ptr<consensus::CommitMsg> commit_msg,
+  Status AsyncAppendCommit(std::unique_ptr<consensus::CommitMsg> commit_msg,
                            const StatusCallback& callback);
 
-
   // Blocks the current thread until all the entries in the log queue
   // are flushed and fsynced (if fsync of log entries is enabled).
   Status WaitUntilAllFlushed();
diff --git a/src/kudu/consensus/log_cache-test.cc b/src/kudu/consensus/log_cache-test.cc
index 7057555..3972696 100644
--- a/src/kudu/consensus/log_cache-test.cc
+++ b/src/kudu/consensus/log_cache-test.cc
@@ -44,7 +44,6 @@
 #include "kudu/consensus/ref_counted_replicate.h"
 #include "kudu/fs/fs_manager.h"
 #include "kudu/gutil/bind.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/strings/substitute.h"
diff --git a/src/kudu/consensus/peer_manager.cc b/src/kudu/consensus/peer_manager.cc
index 370f130..4608e25 100644
--- a/src/kudu/consensus/peer_manager.cc
+++ b/src/kudu/consensus/peer_manager.cc
@@ -20,7 +20,6 @@
 #include <memory>
 #include <mutex>
 #include <ostream>
-#include <type_traits>
 #include <utility>
 
 #include <glog/logging.h>
@@ -28,7 +27,6 @@
 #include "kudu/consensus/consensus_peers.h"
 #include "kudu/consensus/log.h"
 #include "kudu/consensus/metadata.pb.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -36,13 +34,16 @@
 
 using kudu::log::Log;
 using kudu::pb_util::SecureShortDebugString;
+using std::shared_ptr;
+using std::string;
+using std::unique_ptr;
 using strings::Substitute;
 
 namespace kudu {
 namespace consensus {
 
-PeerManager::PeerManager(std::string tablet_id,
-                         std::string local_uuid,
+PeerManager::PeerManager(string tablet_id,
+                         string local_uuid,
                          PeerProxyFactory* peer_proxy_factory,
                          PeerMessageQueue* queue,
                          ThreadPoolToken* raft_pool_token,
@@ -73,11 +74,11 @@ Status PeerManager::UpdateRaftConfig(const RaftConfigPB& config) {
     }
 
     VLOG(1) << GetLogPrefix() << "Adding remote peer. Peer: " << SecureShortDebugString(peer_pb);
-    gscoped_ptr<PeerProxy> peer_proxy;
+    unique_ptr<PeerProxy> peer_proxy;
     RETURN_NOT_OK_PREPEND(peer_proxy_factory_->NewProxy(peer_pb, &peer_proxy),
                           "Could not obtain a remote proxy to the peer.");
 
-    std::shared_ptr<Peer> remote_peer;
+    shared_ptr<Peer> remote_peer;
     RETURN_NOT_OK(Peer::NewRemotePeer(peer_pb,
                                       tablet_id_,
                                       local_uuid_,
@@ -107,8 +108,8 @@ void PeerManager::SignalRequest(bool force_if_queue_empty) {
   }
 }
 
-Status PeerManager::StartElection(const std::string& uuid) {
-  std::shared_ptr<Peer> peer;
+Status PeerManager::StartElection(const string& uuid) {
+  shared_ptr<Peer> peer;
   {
     std::lock_guard<simple_spinlock> lock(lock_);
     peer = FindPtrOrNull(peers_, uuid);
@@ -130,7 +131,7 @@ void PeerManager::Close() {
   }
 }
 
-std::string PeerManager::GetLogPrefix() const {
+string PeerManager::GetLogPrefix() const {
   return Substitute("T $0 P $1: ", tablet_id_, local_uuid_);
 }
 
diff --git a/src/kudu/consensus/raft_consensus.cc b/src/kudu/consensus/raft_consensus.cc
index bf10e63..2aeffb6 100644
--- a/src/kudu/consensus/raft_consensus.cc
+++ b/src/kudu/consensus/raft_consensus.cc
@@ -25,7 +25,6 @@
 #include <memory>
 #include <mutex>
 #include <ostream>
-#include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 
@@ -644,7 +643,7 @@ void RaftConsensus::EndLeaderTransferPeriod() {
 }
 
 scoped_refptr<ConsensusRound> RaftConsensus::NewRound(
-    gscoped_ptr<ReplicateMsg> replicate_msg,
+    unique_ptr<ReplicateMsg> replicate_msg,
     ConsensusReplicatedCallback replicated_cb) {
   return make_scoped_refptr(new ConsensusRound(this,
                                                std::move(replicate_msg),
@@ -2818,7 +2817,7 @@ void RaftConsensus::NonTxRoundReplicationFinished(ConsensusRound* round,
   VLOG_WITH_PREFIX_UNLOCKED(1) << "Committing " << op_type_str << " with op id "
                                << round->id();
   round_handler_->FinishConsensusOnlyRound(round);
-  gscoped_ptr<CommitMsg> commit_msg(new CommitMsg);
+  unique_ptr<CommitMsg> commit_msg(new CommitMsg);
   commit_msg->set_op_type(round->replicate_msg()->op_type());
   *commit_msg->mutable_commited_op_id() = round->id();
 
@@ -3223,7 +3222,7 @@ ConsensusBootstrapInfo::~ConsensusBootstrapInfo() {
 ////////////////////////////////////////////////////////////////////////
 
 ConsensusRound::ConsensusRound(RaftConsensus* consensus,
-                               gscoped_ptr<ReplicateMsg> replicate_msg,
+                               unique_ptr<ReplicateMsg> replicate_msg,
                                ConsensusReplicatedCallback replicated_cb)
     : consensus_(consensus),
       replicate_msg_(new RefCountedReplicate(replicate_msg.release())),
diff --git a/src/kudu/consensus/raft_consensus.h b/src/kudu/consensus/raft_consensus.h
index 99c5638..1a1cef3 100644
--- a/src/kudu/consensus/raft_consensus.h
+++ b/src/kudu/consensus/raft_consensus.h
@@ -14,7 +14,6 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-
 #pragma once
 
 #include <atomic>
@@ -38,7 +37,6 @@
 #include "kudu/consensus/opid.pb.h"
 #include "kudu/consensus/ref_counted_replicate.h"
 #include "kudu/gutil/callback.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
@@ -55,7 +53,7 @@
 namespace kudu {
 
 typedef std::lock_guard<simple_spinlock> Lock;
-typedef gscoped_ptr<Lock> ScopedLock;
+typedef std::unique_ptr<Lock> ScopedLock;
 
 class Status;
 class ThreadPool;
@@ -218,7 +216,7 @@ class RaftConsensus : public std::enable_shared_from_this<RaftConsensus>,
   // (and later on the CommitMsg). ConsensusRound will also point to and
   // increase the reference count for the provided callbacks.
   scoped_refptr<ConsensusRound> NewRound(
-      gscoped_ptr<ReplicateMsg> replicate_msg,
+      std::unique_ptr<ReplicateMsg> replicate_msg,
       ConsensusReplicatedCallback replicated_cb);
 
   // Called by a Leader to replicate an entry to the state machine.
@@ -1005,7 +1003,7 @@ class ConsensusRound : public RefCountedThreadSafe<ConsensusRound> {
   // Ctor used for leader transactions. Leader transactions can and must specify the
   // callbacks prior to initiating the consensus round.
   ConsensusRound(RaftConsensus* consensus,
-                 gscoped_ptr<ReplicateMsg> replicate_msg,
+                 std::unique_ptr<ReplicateMsg> replicate_msg,
                  ConsensusReplicatedCallback replicated_cb);
 
   // Ctor used for follower/learner transactions. These transactions do not use the
diff --git a/src/kudu/consensus/raft_consensus_quorum-test.cc b/src/kudu/consensus/raft_consensus_quorum-test.cc
index 2fb196b..ff21436 100644
--- a/src/kudu/consensus/raft_consensus_quorum-test.cc
+++ b/src/kudu/consensus/raft_consensus_quorum-test.cc
@@ -20,7 +20,6 @@
 #include <memory>
 #include <ostream>
 #include <string>
-#include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
@@ -57,7 +56,6 @@
 #include "kudu/fs/fs_manager.h"
 #include "kudu/gutil/bind.h"
 #include "kudu/gutil/casts.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/strings/strcat.h"
@@ -270,7 +268,7 @@ class RaftConsensusQuorumTest : public KuduTest {
 
   Status AppendDummyMessage(int peer_idx,
                             scoped_refptr<ConsensusRound>* round) {
-    gscoped_ptr<ReplicateMsg> msg(new ReplicateMsg());
+    unique_ptr<ReplicateMsg> msg(new ReplicateMsg());
     msg->set_op_type(NO_OP);
     msg->mutable_noop_request();
     msg->set_timestamp(clock_.Now().ToUint64());
@@ -302,7 +300,7 @@ class RaftConsensusQuorumTest : public KuduTest {
       commit_callback = Bind(&DoNothingStatusCB);
     }
 
-    gscoped_ptr<CommitMsg> msg(new CommitMsg());
+    unique_ptr<CommitMsg> msg(new CommitMsg());
     msg->set_op_type(NO_OP);
     msg->mutable_commited_op_id()->CopyFrom(round->id());
     CHECK_OK(logs_[peer_idx]->AsyncAppendCommit(std::move(msg), commit_callback));
diff --git a/src/kudu/consensus/ref_counted_replicate.h b/src/kudu/consensus/ref_counted_replicate.h
index 712ae14..b2fa844 100644
--- a/src/kudu/consensus/ref_counted_replicate.h
+++ b/src/kudu/consensus/ref_counted_replicate.h
@@ -14,13 +14,10 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-
-#ifndef KUDU_CONSENSUS_REF_COUNTED_REPLICATE_H_
-#define KUDU_CONSENSUS_REF_COUNTED_REPLICATE_H_
+#pragma once
 
 #include "kudu/consensus/consensus.pb.h"
 #include "kudu/gutil/ref_counted.h"
-#include "kudu/gutil/gscoped_ptr.h"
 
 namespace kudu {
 namespace consensus {
@@ -35,7 +32,7 @@ class RefCountedReplicate : public RefCountedThreadSafe<RefCountedReplicate> {
   }
 
  private:
-  gscoped_ptr<ReplicateMsg> msg_;
+  std::unique_ptr<ReplicateMsg> msg_;
 };
 
 typedef scoped_refptr<RefCountedReplicate> ReplicateRefPtr;
@@ -46,5 +43,3 @@ inline ReplicateRefPtr make_scoped_refptr_replicate(ReplicateMsg* replicate) {
 
 } // namespace consensus
 } // namespace kudu
-
-#endif /* KUDU_CONSENSUS_REF_COUNTED_REPLICATE_H_ */
diff --git a/src/kudu/gutil/map-util.h b/src/kudu/gutil/map-util.h
index 7b6d7bb..ae6d2d1 100644
--- a/src/kudu/gutil/map-util.h
+++ b/src/kudu/gutil/map-util.h
@@ -738,7 +738,7 @@ void ReverseMap(const Collection& collection,
 //     delete EraseKeyReturnValuePtr(&my_map, "abc");
 //
 // Use returned value:
-//     gscoped_ptr<MyType> value_ptr(EraseKeyReturnValuePtr(&my_map, "abc"));
+//     unique_ptr<MyType> value_ptr(EraseKeyReturnValuePtr(&my_map, "abc"));
 //     if (value_ptr.get())
 //       value_ptr->DoSomething();
 //
diff --git a/src/kudu/gutil/ref_counted.h b/src/kudu/gutil/ref_counted.h
index b064a42..8183a74 100644
--- a/src/kudu/gutil/ref_counted.h
+++ b/src/kudu/gutil/ref_counted.h
@@ -326,7 +326,7 @@ class scoped_refptr {
     swap(&r.ptr_);
   }
 
-  // Like gscoped_ptr::reset(), drops a reference on the currently held object
+  // Like unique_ptr::reset(), drops a reference on the currently held object
   // (if any), and adds a reference to the passed-in object (if not NULL).
   void reset(T* p = NULL) {
     *this = p;
diff --git a/src/kudu/integration-tests/all_types-itest.cc b/src/kudu/integration-tests/all_types-itest.cc
index aa242d7..f77d4c1 100644
--- a/src/kudu/integration-tests/all_types-itest.cc
+++ b/src/kudu/integration-tests/all_types-itest.cc
@@ -18,6 +18,7 @@
 #include <algorithm>
 #include <cstdint>
 #include <functional>
+#include <memory>
 #include <ostream>
 #include <string>
 #include <utility>
@@ -37,7 +38,6 @@
 #include "kudu/common/common.pb.h"
 #include "kudu/common/partial_row.h"
 #include "kudu/common/types.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/mathlimits.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/stringprintf.h"
@@ -56,16 +56,16 @@
 
 DEFINE_int32(num_rows_per_tablet, 100, "The number of rows to be inserted into each tablet");
 
+using kudu::cluster::ExternalMiniCluster;
+using kudu::cluster::ExternalMiniClusterOptions;
+using kudu::client::sp::shared_ptr;
 using std::string;
+using std::unique_ptr;
 using std::vector;
 
 namespace kudu {
 namespace client {
 
-using cluster::ExternalMiniCluster;
-using cluster::ExternalMiniClusterOptions;
-using sp::shared_ptr;
-
 static const int kNumTabletServers = 3;
 static const int kNumTablets = 3;
 static const int kMaxBatchSize = 8 * 1024 * 1024;
@@ -409,7 +409,7 @@ class AllTypesItest : public KuduTest {
   Status CreateTable() {
     CreateAllTypesSchema();
     vector<const KuduPartialRow*> split_rows = setup_.GenerateSplitRows(schema_);
-    gscoped_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
+    unique_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
 
     for (const KuduPartialRow* row : split_rows) {
       split_rows_.push_back(*row);
@@ -632,7 +632,7 @@ class AllTypesItest : public KuduTest {
   KuduSchema schema_;
   vector<KuduPartialRow> split_rows_;
   shared_ptr<KuduClient> client_;
-  gscoped_ptr<ExternalMiniCluster> cluster_;
+  unique_ptr<ExternalMiniCluster> cluster_;
   shared_ptr<KuduTable> table_;
 };
 
diff --git a/src/kudu/integration-tests/alter_table-test.cc b/src/kudu/integration-tests/alter_table-test.cc
index 8cab86c..5798f99 100644
--- a/src/kudu/integration-tests/alter_table-test.cc
+++ b/src/kudu/integration-tests/alter_table-test.cc
@@ -46,7 +46,6 @@
 #include "kudu/common/schema.h"
 #include "kudu/common/wire_protocol.h"
 #include "kudu/consensus/raft_consensus.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/stl_util.h"
@@ -146,7 +145,7 @@ class AlterTableTest : public KuduTest {
         .Build(&client_));
 
     // Add a table, make sure it reports itself.
-    gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+    unique_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
     CHECK_OK(table_creator->table_name(kTableName)
              .schema(&schema_)
              .set_range_partition_columns({ "c0" })
@@ -225,7 +224,7 @@ class AlterTableTest : public KuduTest {
                          const string& column_name,
                          int32_t default_value,
                          const MonoDelta& timeout) {
-    gscoped_ptr<KuduTableAlterer> table_alterer(client_->NewTableAlterer(table_name));
+    unique_ptr<KuduTableAlterer> table_alterer(client_->NewTableAlterer(table_name));
     table_alterer->AddColumn(column_name)->Type(KuduColumnSchema::INT32)->
       NotNull()->Default(KuduValue::FromInt(default_value));
     return table_alterer->timeout(timeout)->Alter();
@@ -259,7 +258,7 @@ class AlterTableTest : public KuduTest {
       CHECK_OK(row->SetInt32(0, i * 100));
       split_rows.push_back(row);
     }
-    gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+    unique_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
     return table_creator->table_name(table_name)
@@ -291,7 +290,7 @@ class AlterTableTest : public KuduTest {
 
   static const char *kTableName;
 
-  gscoped_ptr<InternalMiniCluster> cluster_;
+  unique_ptr<InternalMiniCluster> cluster_;
   shared_ptr<KuduClient> client_;
 
   KuduSchema schema_;
@@ -375,7 +374,7 @@ TEST_F(AlterTableTest, TestAddNullableColumnWithoutDefault) {
   ASSERT_OK(tablet_replica_->tablet()->Flush());
 
   {
-    gscoped_ptr<KuduTableAlterer> table_alterer(client_->NewTableAlterer(kTableName));
+    unique_ptr<KuduTableAlterer> table_alterer(client_->NewTableAlterer(kTableName));
     table_alterer->AddColumn("new")->Type(KuduColumnSchema::INT32);
     ASSERT_OK(table_alterer->Alter());
   }
@@ -395,7 +394,7 @@ TEST_F(AlterTableTest, TestRenamePrimaryKeyColumn) {
   ASSERT_OK(tablet_replica_->tablet()->Flush());
 
   {
-    gscoped_ptr<KuduTableAlterer> table_alterer(client_->NewTableAlterer(kTableName));
+    unique_ptr<KuduTableAlterer> table_alterer(client_->NewTableAlterer(kTableName));
     table_alterer->AlterColumn("c0")->RenameTo("primaryKeyRenamed");
     table_alterer->AlterColumn("c1")->RenameTo("secondColumn");
     ASSERT_OK(table_alterer->Alter());
@@ -410,7 +409,7 @@ TEST_F(AlterTableTest, TestRenamePrimaryKeyColumn) {
   EXPECT_EQ("(int32 primaryKeyRenamed=16777216, int32 secondColumn=1)", rows[1]);
 
   {
-    gscoped_ptr<KuduTableAlterer> table_alterer(client_->NewTableAlterer(kTableName));
+    unique_ptr<KuduTableAlterer> table_alterer(client_->NewTableAlterer(kTableName));
     table_alterer->AlterColumn("primaryKeyRenamed")->RenameTo("pk");
     table_alterer->AlterColumn("secondColumn")->RenameTo("sc");
     ASSERT_OK(table_alterer->Alter());
@@ -622,7 +621,7 @@ void AlterTableTest::InsertRows(int start_row, int num_rows) {
 
   // Insert a bunch of rows with the current schema
   for (int i = start_row; i < start_row + num_rows; i++) {
-    gscoped_ptr<KuduInsert> insert(table->NewInsert());
+    unique_ptr<KuduInsert> insert(table->NewInsert());
     // Endian-swap the key so that we spew inserts randomly
     // instead of just a sequential write pattern. This way
     // compactions may actually be triggered.
diff --git a/src/kudu/integration-tests/catalog_manager_tsk-itest.cc b/src/kudu/integration-tests/catalog_manager_tsk-itest.cc
index d3e7dab..ac196ea 100644
--- a/src/kudu/integration-tests/catalog_manager_tsk-itest.cc
+++ b/src/kudu/integration-tests/catalog_manager_tsk-itest.cc
@@ -17,13 +17,14 @@
 
 #include <algorithm>
 #include <atomic>
-#include <cstdlib>
 #include <cstdint>
+#include <cstdlib>
 #include <iterator>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <thread>
+#include <utility>
 #include <vector>
 
 #include <glog/logging.h>
@@ -37,7 +38,6 @@
 #include "kudu/common/partial_row.h"
 #include "kudu/consensus/consensus.pb.h"
 #include "kudu/consensus/consensus.proxy.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/master/sys_catalog.h"
 #include "kudu/mini-cluster/external_mini_cluster.h"
@@ -121,7 +121,7 @@ class CatalogManagerTskITest : public KuduTest {
 
     // Create a table.
     auto schema = KuduSchema::FromSchema(CreateKeyValueTestSchema());
-    gscoped_ptr<KuduTableCreator> table_creator(client->NewTableCreator());
+    unique_ptr<KuduTableCreator> table_creator(client->NewTableCreator());
 
     ASSERT_OK(table_creator->table_name(kTableName)
               .set_range_partition_columns({ "key" })
diff --git a/src/kudu/integration-tests/client-stress-test.cc b/src/kudu/integration-tests/client-stress-test.cc
index 102de8b..139f4a7 100644
--- a/src/kudu/integration-tests/client-stress-test.cc
+++ b/src/kudu/integration-tests/client-stress-test.cc
@@ -18,6 +18,7 @@
 #include <unistd.h>
 
 #include <cstdint>
+#include <memory>
 #include <ostream>
 #include <set>
 #include <string>
@@ -33,7 +34,6 @@
 #include "kudu/client/scan_predicate.h"
 #include "kudu/client/shared_ptr.h"
 #include "kudu/client/value.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/strings/join.h"
@@ -58,6 +58,7 @@ METRIC_DECLARE_counter(follower_memory_pressure_rejections);
 using strings::Substitute;
 using std::set;
 using std::string;
+using std::unique_ptr;
 using std::vector;
 
 namespace kudu {
@@ -111,7 +112,7 @@ class ClientStressTest : public KuduTest {
     return ExternalMiniClusterOptions();
   }
 
-  gscoped_ptr<ExternalMiniCluster> cluster_;
+  unique_ptr<ExternalMiniCluster> cluster_;
 };
 
 // Stress test a case where most of the operations are expected to time out.
diff --git a/src/kudu/integration-tests/consensus_peer_health_status-itest.cc b/src/kudu/integration-tests/consensus_peer_health_status-itest.cc
index 097787d..7139640 100644
--- a/src/kudu/integration-tests/consensus_peer_health_status-itest.cc
+++ b/src/kudu/integration-tests/consensus_peer_health_status-itest.cc
@@ -15,9 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <initializer_list>
 #include <memory>
 #include <ostream>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include <gflags/gflags_declare.h>
@@ -26,7 +28,6 @@
 
 #include "kudu/consensus/consensus.pb.h"
 #include "kudu/consensus/metadata.pb.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/integration-tests/cluster_itest_util.h"
 #include "kudu/integration-tests/raft_consensus-itest-base.h"
diff --git a/src/kudu/integration-tests/create-table-itest.cc b/src/kudu/integration-tests/create-table-itest.cc
index c7b91f1..5421a78 100644
--- a/src/kudu/integration-tests/create-table-itest.cc
+++ b/src/kudu/integration-tests/create-table-itest.cc
@@ -38,7 +38,6 @@
 #include "kudu/common/partial_row.h"
 #include "kudu/common/schema.h"
 #include "kudu/common/wire_protocol-test-util.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/mathlimits.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -110,7 +109,7 @@ TEST_F(CreateTableITest, TestCreateWhenMajorityOfReplicasFailCreation) {
   // Try to create a single-tablet table.
   // This won't succeed because we can't create enough replicas to get
   // a quorum.
-  gscoped_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
+  unique_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
   auto client_schema = KuduSchema::FromSchema(GetSimpleTestSchema());
   ASSERT_OK(table_creator->table_name(kTableName)
             .schema(&client_schema)
@@ -196,7 +195,7 @@ TEST_F(CreateTableITest, TestSpreadReplicasEvenly) {
   const int kNumTablets = 20;
   NO_FATALS(StartCluster({}, {}, kNumServers));
 
-  gscoped_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
+  unique_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
   auto client_schema = KuduSchema::FromSchema(GetSimpleTestSchema());
   ASSERT_OK(table_creator->table_name(kTableName)
             .schema(&client_schema)
@@ -280,7 +279,7 @@ TEST_F(CreateTableITest, TestSpreadReplicasEvenlyWithDimension) {
                               int32_t range_lower_bound,
                               int32_t range_upper_bound,
                               const string& dimension_label) -> Status {
-    gscoped_ptr<client::KuduTableCreator> table_creator(client->NewTableCreator());
+    unique_ptr<client::KuduTableCreator> table_creator(client->NewTableCreator());
     unique_ptr<KuduPartialRow> lower_bound(client_schema->NewRow());
     RETURN_NOT_OK(lower_bound->SetInt32("key2", range_lower_bound));
     unique_ptr<KuduPartialRow> upper_bound(client_schema->NewRow());
@@ -301,7 +300,7 @@ TEST_F(CreateTableITest, TestSpreadReplicasEvenlyWithDimension) {
                              int32_t range_lower_bound,
                              int32_t range_upper_bound,
                              const string& dimension_label) -> Status {
-    gscoped_ptr<client::KuduTableAlterer> table_alterer(client->NewTableAlterer(table_name));
+    unique_ptr<client::KuduTableAlterer> table_alterer(client->NewTableAlterer(table_name));
     unique_ptr<KuduPartialRow> lower_bound(client_schema->NewRow());
     RETURN_NOT_OK(lower_bound->SetInt32("key2", range_lower_bound));
     unique_ptr<KuduPartialRow> upper_bound(client_schema->NewRow());
@@ -399,7 +398,7 @@ static void LookUpRandomKeysLoop(const std::shared_ptr<master::MasterServiceProx
                                  AtomicBool* quit) {
   Schema schema(GetSimpleTestSchema());
   auto client_schema = KuduSchema::FromSchema(GetSimpleTestSchema());
-  gscoped_ptr<KuduPartialRow> r(client_schema.NewRow());
+  unique_ptr<KuduPartialRow> r(client_schema.NewRow());
 
   while (!quit->Load()) {
     master::GetTableLocationsRequestPB req;
@@ -467,7 +466,7 @@ TEST_F(CreateTableITest, TestCreateTableWithDeadTServers) {
 
   Schema schema(GetSimpleTestSchema());
   auto client_schema = KuduSchema::FromSchema(GetSimpleTestSchema());
-  gscoped_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
+  unique_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
 
   // Don't bother waiting for table creation to finish; it'll never happen
   // because all of the tservers are dead.
diff --git a/src/kudu/integration-tests/decimal-itest.cc b/src/kudu/integration-tests/decimal-itest.cc
index 5fdbd11..e0eccbc 100644
--- a/src/kudu/integration-tests/decimal-itest.cc
+++ b/src/kudu/integration-tests/decimal-itest.cc
@@ -16,8 +16,8 @@
 // under the License.
 
 #include <cstdint>
+#include <memory>
 #include <string>
-#include <vector>
 
 #include <glog/logging.h>
 #include <gtest/gtest.h>
@@ -30,14 +30,13 @@
 #include "kudu/client/write_op.h"
 #include "kudu/common/partial_row.h"
 #include "kudu/integration-tests/external_mini_cluster-itest-base.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/util/decimal_util.h"
 #include "kudu/util/int128.h"
 #include "kudu/util/status.h"
 #include "kudu/util/test_macros.h"
 
 using std::string;
-using std::vector;
+using std::unique_ptr;
 
 namespace kudu {
 namespace client {
@@ -89,7 +88,7 @@ TEST_F(DecimalItest, TestDecimalTypes) {
   ASSERT_OK(builder.Build(&schema));
 
   // Create Table
-  gscoped_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
+  unique_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
   ASSERT_OK(table_creator->table_name(kTableName)
       .schema(&schema)
       .num_replicas(kNumServers)
@@ -99,7 +98,7 @@ TEST_F(DecimalItest, TestDecimalTypes) {
   ASSERT_OK(client_->OpenTable(kTableName, &table));
 
   // Alter Default Value
-  gscoped_ptr<client::KuduTableAlterer> table_alterer(client_->NewTableAlterer(kTableName));
+  unique_ptr<client::KuduTableAlterer> table_alterer(client_->NewTableAlterer(kTableName));
   table_alterer->AlterColumn("alteredDefault")->Default(KuduValue::FromDecimal(456789, 2));
   ASSERT_OK(table_alterer->Alter());
 
diff --git a/src/kudu/integration-tests/delete_table-itest.cc b/src/kudu/integration-tests/delete_table-itest.cc
index ce0fdd9..7086b86 100644
--- a/src/kudu/integration-tests/delete_table-itest.cc
+++ b/src/kudu/integration-tests/delete_table-itest.cc
@@ -19,6 +19,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <initializer_list>
 #include <limits>
 #include <memory>
 #include <ostream>
@@ -46,7 +47,6 @@
 #include "kudu/consensus/consensus.pb.h"
 #include "kudu/consensus/metadata.pb.h"
 #include "kudu/gutil/basictypes.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/strings/split.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -1381,7 +1381,7 @@ TEST_P(DeleteTableTombstonedParamTest, TestTabletTombstone) {
   KuduPartialRow* split_row = client_schema.NewRow();
   ASSERT_OK(split_row->SetInt32(0, numeric_limits<int32_t>::max() / kNumTablets));
   split_rows.push_back(split_row);
-  gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+  unique_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   ASSERT_OK(table_creator->table_name(TestWorkload::kDefaultTableName)
diff --git a/src/kudu/integration-tests/exactly_once_writes-itest.cc b/src/kudu/integration-tests/exactly_once_writes-itest.cc
index 7ab92c4..53b19d1 100644
--- a/src/kudu/integration-tests/exactly_once_writes-itest.cc
+++ b/src/kudu/integration-tests/exactly_once_writes-itest.cc
@@ -19,6 +19,7 @@
 #include <memory>
 #include <ostream>
 #include <string>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
@@ -30,7 +31,6 @@
 #include "kudu/common/wire_protocol-test-util.h"
 #include "kudu/common/wire_protocol.h"
 #include "kudu/common/wire_protocol.pb.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/strings/substitute.h"
diff --git a/src/kudu/integration-tests/flex_partitioning-itest.cc b/src/kudu/integration-tests/flex_partitioning-itest.cc
index 4eeaa68..68ecc8e 100644
--- a/src/kudu/integration-tests/flex_partitioning-itest.cc
+++ b/src/kudu/integration-tests/flex_partitioning-itest.cc
@@ -40,7 +40,6 @@
 #include "kudu/client/write_op.h"
 #include "kudu/common/common.pb.h"
 #include "kudu/common/partial_row.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/integration-tests/cluster_itest_util.h"
@@ -209,7 +208,7 @@ class FlexPartitioningITest : public KuduTest,
     KuduSchema schema;
     ASSERT_OK(b.Build(&schema));
 
-    gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+    unique_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
     table_creator->table_name(kTableName)
         .schema(&schema)
         .num_replicas(1);
@@ -316,7 +315,7 @@ class FlexPartitioningITest : public KuduTest,
 
   Random random_;
 
-  gscoped_ptr<ExternalMiniCluster> cluster_;
+  unique_ptr<ExternalMiniCluster> cluster_;
 
   shared_ptr<KuduClient> client_;
   shared_ptr<KuduTable> table_;
@@ -339,7 +338,7 @@ Status FlexPartitioningITest::InsertRows(const RangePartitionOptions& range_part
   int count = 0;
   for (const auto& bound : bounds) {
     for (int32_t i = bound.first[0]; i < bound.second[0]; i++) {
-      gscoped_ptr<KuduInsert> insert(table_->NewInsert());
+      unique_ptr<KuduInsert> insert(table_->NewInsert());
       GenerateDataForRow(table_->schema(), i, &random_, insert->mutable_row());
       inserted_rows_.emplace_back(new KuduPartialRow(*insert->mutable_row()));
       RETURN_NOT_OK(session->Apply(insert.release()));
diff --git a/src/kudu/integration-tests/fuzz-itest.cc b/src/kudu/integration-tests/fuzz-itest.cc
index fd3a904..774ba1e 100644
--- a/src/kudu/integration-tests/fuzz-itest.cc
+++ b/src/kudu/integration-tests/fuzz-itest.cc
@@ -48,7 +48,6 @@
 #include "kudu/common/partial_row.h"
 #include "kudu/common/schema.h"
 #include "kudu/gutil/casts.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/strings/join.h"
@@ -276,7 +275,7 @@ class FuzzTest : public KuduTest {
              .default_admin_operation_timeout(MonoDelta::FromSeconds(60))
              .Build(&client_));
     // Add a table, make sure it reports itself.
-    gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+    unique_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
     CHECK_OK(table_creator->table_name(kTableName)
              .schema(&schema_)
              .set_range_partition_columns({ "key" })
@@ -667,7 +666,7 @@ class FuzzTest : public KuduTest {
                    int update_multiplier);
 
   KuduSchema schema_;
-  gscoped_ptr<InternalMiniCluster> cluster_;
+  unique_ptr<InternalMiniCluster> cluster_;
   shared_ptr<KuduClient> client_;
   shared_ptr<KuduSession> session_;
   shared_ptr<KuduTable> table_;
diff --git a/src/kudu/integration-tests/linked_list-test.cc b/src/kudu/integration-tests/linked_list-test.cc
index fb4918c..8aa545a 100644
--- a/src/kudu/integration-tests/linked_list-test.cc
+++ b/src/kudu/integration-tests/linked_list-test.cc
@@ -31,6 +31,7 @@
 // either zero or one times, and no link_to refers to a missing key.
 
 #include <cstdint>
+#include <memory>
 #include <ostream>
 #include <string>
 #include <unordered_map>
@@ -44,7 +45,6 @@
 
 #include "kudu/client/shared_ptr.h"
 #include "kudu/common/wire_protocol.pb.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/integration-tests/cluster_itest_util.h"
 #include "kudu/integration-tests/linked_list-test-util.h"
@@ -82,6 +82,7 @@ using kudu::itest::WaitForReplicasReportedToMaster;
 using kudu::itest::WaitForServersToAgree;
 using kudu::master::VOTER_REPLICA;
 using std::string;
+using std::unique_ptr;
 using std::vector;
 
 namespace kudu {
@@ -156,7 +157,7 @@ class LinkedListTest : public tserver::TabletServerIntegrationTestBase {
 
  protected:
   shared_ptr<client::KuduClient> client_;
-  gscoped_ptr<LinkedListTester> tester_;
+  unique_ptr<LinkedListTester> tester_;
 };
 
 TEST_F(LinkedListTest, TestLoadAndVerify) {
diff --git a/src/kudu/integration-tests/location_assignment-itest.cc b/src/kudu/integration-tests/location_assignment-itest.cc
index ce1d891..b4510ba 100644
--- a/src/kudu/integration-tests/location_assignment-itest.cc
+++ b/src/kudu/integration-tests/location_assignment-itest.cc
@@ -31,7 +31,6 @@
 #include "kudu/client/client.h"
 #include "kudu/client/shared_ptr.h"
 #include "kudu/common/wire_protocol.pb.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/substitute.h"
diff --git a/src/kudu/integration-tests/master_replication-itest.cc b/src/kudu/integration-tests/master_replication-itest.cc
index d527feb..d61ae91 100644
--- a/src/kudu/integration-tests/master_replication-itest.cc
+++ b/src/kudu/integration-tests/master_replication-itest.cc
@@ -33,7 +33,6 @@
 #include "kudu/common/partial_row.h"
 #include "kudu/common/wire_protocol.pb.h"
 #include "kudu/consensus/replica_management.pb.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -171,7 +170,7 @@ class MasterReplicationTest : public KuduTest {
     b.AddColumn("int_val")->Type(KuduColumnSchema::INT32)->NotNull();
     b.AddColumn("string_val")->Type(KuduColumnSchema::STRING)->NotNull();
     CHECK_OK(b.Build(&schema));
-    gscoped_ptr<KuduTableCreator> table_creator(client->NewTableCreator());
+    unique_ptr<KuduTableCreator> table_creator(client->NewTableCreator());
     return table_creator->table_name(table_name)
         .set_range_partition_columns({ "key" })
         .schema(&schema)
@@ -180,7 +179,7 @@ class MasterReplicationTest : public KuduTest {
 
  protected:
   InternalMiniClusterOptions opts_;
-  gscoped_ptr<InternalMiniCluster> cluster_;
+  unique_ptr<InternalMiniCluster> cluster_;
 };
 
 // Basic test. Verify that:
diff --git a/src/kudu/integration-tests/raft_config_change-itest.cc b/src/kudu/integration-tests/raft_config_change-itest.cc
index 38b881c..5d540fe 100644
--- a/src/kudu/integration-tests/raft_config_change-itest.cc
+++ b/src/kudu/integration-tests/raft_config_change-itest.cc
@@ -16,6 +16,7 @@
 // under the License.
 
 #include <cstdint>
+#include <initializer_list>
 #include <memory>
 #include <ostream>
 #include <string>
@@ -34,7 +35,6 @@
 #include "kudu/consensus/consensus.pb.h"
 #include "kudu/consensus/metadata.pb.h"
 #include "kudu/consensus/quorum_util.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/integration-tests/cluster_itest_util.h"
diff --git a/src/kudu/integration-tests/raft_consensus-itest-base.cc b/src/kudu/integration-tests/raft_consensus-itest-base.cc
index ef28531..fe238c7 100644
--- a/src/kudu/integration-tests/raft_consensus-itest-base.cc
+++ b/src/kudu/integration-tests/raft_consensus-itest-base.cc
@@ -19,6 +19,7 @@
 
 #include <algorithm>
 #include <cstdint>
+#include <memory>
 #include <ostream>
 #include <string>
 #include <unordered_map>
@@ -37,7 +38,6 @@
 #include "kudu/common/wire_protocol.h"
 #include "kudu/consensus/consensus.pb.h"
 #include "kudu/consensus/opid.pb.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/stringprintf.h"
@@ -83,6 +83,7 @@ using kudu::itest::TServerDetails;
 using kudu::pb_util::SecureDebugString;
 using kudu::rpc::RpcController;
 using std::string;
+using std::unique_ptr;
 using std::vector;
 
 namespace kudu {
@@ -151,7 +152,7 @@ void RaftConsensusITestBase::InsertTestRowsRemoteThread(
     uint64_t last_row_in_batch = first_row_in_batch + count / num_batches;
 
     for (int j = first_row_in_batch; j < last_row_in_batch; j++) {
-      gscoped_ptr<KuduInsert> insert(table->NewInsert());
+      unique_ptr<KuduInsert> insert(table->NewInsert());
       KuduPartialRow* row = insert->mutable_row();
       CHECK_OK(row->SetInt32(0, j));
       CHECK_OK(row->SetInt32(1, j * 2));
diff --git a/src/kudu/integration-tests/raft_consensus-itest.cc b/src/kudu/integration-tests/raft_consensus-itest.cc
index ef14ce6..8c22508 100644
--- a/src/kudu/integration-tests/raft_consensus-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus-itest.cc
@@ -45,7 +45,6 @@
 #include "kudu/consensus/opid_util.h"
 #include "kudu/consensus/quorum_util.h"
 #include "kudu/gutil/basictypes.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/stl_util.h"
@@ -147,6 +146,7 @@ using kudu::rpc::RpcController;
 using kudu::server::SetFlagRequestPB;
 using kudu::server::SetFlagResponsePB;
 using std::string;
+using std::unique_ptr;
 using std::unordered_map;
 using std::vector;
 using strings::Substitute;
@@ -321,7 +321,7 @@ void RaftConsensusITest::InsertPayloadIgnoreErrors(int start_row,
   CHECK_OK(session->SetFlushMode(KuduSession::MANUAL_FLUSH));
   string payload(payload_size, 'x');
   for (int i = 0; i < num_rows; i++) {
-    gscoped_ptr<KuduInsert> insert(table->NewInsert());
+    unique_ptr<KuduInsert> insert(table->NewInsert());
     KuduPartialRow* row = insert->mutable_row();
     CHECK_OK(row->SetInt32(0, i + start_row));
     CHECK_OK(row->SetInt32(1, 0));
diff --git a/src/kudu/integration-tests/raft_consensus_election-itest.cc b/src/kudu/integration-tests/raft_consensus_election-itest.cc
index 287f8f6..c78c3f7 100644
--- a/src/kudu/integration-tests/raft_consensus_election-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus_election-itest.cc
@@ -17,6 +17,7 @@
 
 #include <cstdint>
 #include <initializer_list>
+#include <memory>
 #include <ostream>
 #include <string>
 #include <unordered_map>
@@ -33,7 +34,6 @@
 #include "kudu/consensus/metadata.pb.h"
 #include "kudu/consensus/opid.pb.h"
 #include "kudu/consensus/opid_util.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/integration-tests/cluster_itest_util.h"
diff --git a/src/kudu/integration-tests/raft_consensus_nonvoter-itest.cc b/src/kudu/integration-tests/raft_consensus_nonvoter-itest.cc
index 6bf794e..1392f20 100644
--- a/src/kudu/integration-tests/raft_consensus_nonvoter-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus_nonvoter-itest.cc
@@ -17,6 +17,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <numeric>
 #include <ostream>
 #include <string>
@@ -36,7 +37,6 @@
 #include "kudu/consensus/consensus.pb.h"
 #include "kudu/consensus/metadata.pb.h"
 #include "kudu/consensus/quorum_util.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/substitute.h"
diff --git a/src/kudu/integration-tests/raft_consensus_stress-itest.cc b/src/kudu/integration-tests/raft_consensus_stress-itest.cc
index fee4cfd..7191542 100644
--- a/src/kudu/integration-tests/raft_consensus_stress-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus_stress-itest.cc
@@ -18,17 +18,16 @@
 #include <atomic>
 #include <cstdint>
 #include <cstdlib>
+#include <memory>
 #include <ostream>
 #include <string>
 #include <thread>
 #include <vector>
 
 #include <gflags/gflags.h>
-#include <gflags/gflags_declare.h>
 #include <glog/logging.h>
 #include <gtest/gtest.h>
 
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/integration-tests/cluster_itest_util.h"
 #include "kudu/integration-tests/cluster_verifier.h"
diff --git a/src/kudu/integration-tests/registration-test.cc b/src/kudu/integration-tests/registration-test.cc
index e5f6916..bae2843 100644
--- a/src/kudu/integration-tests/registration-test.cc
+++ b/src/kudu/integration-tests/registration-test.cc
@@ -21,6 +21,7 @@
 #include <memory>
 #include <ostream>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include <boost/optional/optional.hpp>
@@ -32,7 +33,6 @@
 #include "kudu/common/schema.h"
 #include "kudu/common/wire_protocol.h"
 #include "kudu/common/wire_protocol.pb.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/gutil/walltime.h"
@@ -69,25 +69,25 @@ METRIC_DECLARE_counter(rows_inserted);
 METRIC_DECLARE_counter(rows_updated);
 
 using boost::none;
+using kudu::cluster::InternalMiniCluster;
+using kudu::master::CatalogManager;
+using kudu::master::CreateTableRequestPB;
+using kudu::master::CreateTableResponsePB;
+using kudu::master::GetTableLocationsResponsePB;
+using kudu::master::IsCreateTableDoneRequestPB;
+using kudu::master::IsCreateTableDoneResponsePB;
+using kudu::master::MiniMaster;
+using kudu::master::TSDescriptor;
+using kudu::master::TabletLocationsPB;
+using kudu::pb_util::SecureShortDebugString;
+using kudu::tserver::MiniTabletServer;
 using std::shared_ptr;
 using std::string;
+using std::unique_ptr;
 using std::vector;
 
 namespace kudu {
 
-using cluster::InternalMiniCluster;
-using master::CatalogManager;
-using master::CreateTableRequestPB;
-using master::CreateTableResponsePB;
-using master::GetTableLocationsResponsePB;
-using master::IsCreateTableDoneRequestPB;
-using master::IsCreateTableDoneResponsePB;
-using master::MiniMaster;
-using master::TSDescriptor;
-using master::TabletLocationsPB;
-using kudu::pb_util::SecureShortDebugString;
-using tserver::MiniTabletServer;
-
 void CreateTableForTesting(MiniMaster* mini_master,
                            const string& table_name,
                            const Schema& schema,
@@ -218,7 +218,7 @@ class RegistrationTest : public KuduTest {
   }
 
  protected:
-  gscoped_ptr<InternalMiniCluster> cluster_;
+  unique_ptr<InternalMiniCluster> cluster_;
   Schema schema_;
   int64_t setup_time_;
 };
diff --git a/src/kudu/integration-tests/security-faults-itest.cc b/src/kudu/integration-tests/security-faults-itest.cc
index 9fb5fab..b64aac6 100644
--- a/src/kudu/integration-tests/security-faults-itest.cc
+++ b/src/kudu/integration-tests/security-faults-itest.cc
@@ -34,7 +34,6 @@
 #include "kudu/client/shared_ptr.h"
 #include "kudu/client/write_op.h"
 #include "kudu/common/partial_row.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/mini-cluster/external_mini_cluster.h"
 #include "kudu/security/test/mini_kdc.h"
@@ -124,7 +123,7 @@ class SecurityComponentsFaultsITest : public KuduTest {
 
     // Create a table.
     KuduSchema schema = KuduSchema::FromSchema(CreateKeyValueTestSchema());
-    gscoped_ptr<KuduTableCreator> table_creator(client->NewTableCreator());
+    unique_ptr<KuduTableCreator> table_creator(client->NewTableCreator());
 
     RETURN_NOT_OK(table_creator->table_name(kTableName)
                   .set_range_partition_columns({ "key" })
diff --git a/src/kudu/integration-tests/security-unknown-tsk-itest.cc b/src/kudu/integration-tests/security-unknown-tsk-itest.cc
index 97b530c..6beffbf 100644
--- a/src/kudu/integration-tests/security-unknown-tsk-itest.cc
+++ b/src/kudu/integration-tests/security-unknown-tsk-itest.cc
@@ -37,7 +37,6 @@
 #include "kudu/client/shared_ptr.h"
 #include "kudu/client/write_op.h"
 #include "kudu/common/partial_row.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/walltime.h"
 #include "kudu/integration-tests/test_workload.h"
@@ -217,7 +216,7 @@ TEST_F(SecurityUnknownTskTest, ErrorUnavailableCommonOperations) {
   // calls to the tablet server. The table should consists of multiple tablets
   // hosted by all available tablet servers, so the insert or scan requests are
   // sent to all avaialble tablet servers.
-  gscoped_ptr<KuduTableCreator> table_creator(client->NewTableCreator());
+  unique_ptr<KuduTableCreator> table_creator(client->NewTableCreator());
   shared_ptr<KuduTable> table;
   ASSERT_OK(table_creator->table_name(table_name)
       .set_range_partition_columns({ "key" })
diff --git a/src/kudu/integration-tests/tablet_copy-itest.cc b/src/kudu/integration-tests/tablet_copy-itest.cc
index 53ec383..f3183c0 100644
--- a/src/kudu/integration-tests/tablet_copy-itest.cc
+++ b/src/kudu/integration-tests/tablet_copy-itest.cc
@@ -17,6 +17,7 @@
 
 #include <atomic>
 #include <cstdint>
+#include <initializer_list>
 #include <limits>
 #include <memory>
 #include <mutex>
@@ -48,7 +49,6 @@
 #include "kudu/consensus/opid_util.h"
 #include "kudu/fs/fs_manager.h"
 #include "kudu/gutil/basictypes.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -128,6 +128,7 @@ using std::mutex;
 using std::set;
 using std::string;
 using std::thread;
+using std::unique_ptr;
 using std::unordered_map;
 using std::vector;
 using strings::Substitute;
@@ -501,7 +502,7 @@ TEST_F(TabletCopyITest, TestDeleteTabletDuringTabletCopy) {
   ASSERT_OK(env_->CreateDir(testbase));
   opts.wal_root = JoinPathSegments(testbase, "wals");
   opts.data_roots.push_back(JoinPathSegments(testbase, "data-0"));
-  gscoped_ptr<FsManager> fs_manager(new FsManager(env_, opts));
+  unique_ptr<FsManager> fs_manager(new FsManager(env_, opts));
   ASSERT_OK(fs_manager->CreateInitialFileSystemLayout());
   ASSERT_OK(fs_manager->Open());
   scoped_refptr<ConsensusMetadataManager> cmeta_manager(
@@ -642,7 +643,7 @@ TEST_F(TabletCopyITest, TestConcurrentTabletCopys) {
   }
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-  gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+  unique_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
   ASSERT_OK(table_creator->table_name(TestWorkload::kDefaultTableName)
                           .split_rows(splits)
                           .schema(&client_schema)
diff --git a/src/kudu/integration-tests/test_workload.cc b/src/kudu/integration-tests/test_workload.cc
index 43d3797..441e22b 100644
--- a/src/kudu/integration-tests/test_workload.cc
+++ b/src/kudu/integration-tests/test_workload.cc
@@ -28,7 +28,6 @@
 #include "kudu/client/write_op.h"
 #include "kudu/common/partial_row.h"
 #include "kudu/common/wire_protocol-test-util.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/mathlimits.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/stl_util.h"
@@ -38,25 +37,25 @@
 #include "kudu/util/status.h"
 #include "kudu/util/test_util.h"
 
-namespace kudu {
-
-using client::KuduClient;
-using client::KuduColumnSchema;
-using client::KuduDelete;
-using client::KuduError;
-using client::KuduInsert;
-using client::KuduScanBatch;
-using client::KuduScanner;
-using client::KuduSchema;
-using client::KuduSession;
-using client::KuduTable;
-using client::KuduTableCreator;
-using client::KuduUpdate;
-using client::sp::shared_ptr;
-using cluster::MiniCluster;
-
+using kudu::client::KuduClient;
+using kudu::client::KuduColumnSchema;
+using kudu::client::KuduDelete;
+using kudu::client::KuduError;
+using kudu::client::KuduInsert;
+using kudu::client::KuduScanBatch;
+using kudu::client::KuduScanner;
+using kudu::client::KuduSchema;
+using kudu::client::KuduSession;
+using kudu::client::KuduTable;
+using kudu::client::KuduTableCreator;
+using kudu::client::KuduUpdate;
+using kudu::client::sp::shared_ptr;
+using kudu::cluster::MiniCluster;
+using std::unique_ptr;
 using std::vector;
 
+namespace kudu {
+
 const char* const TestWorkload::kDefaultTableName = "test-workload";
 
 TestWorkload::TestWorkload(MiniCluster* cluster)
@@ -152,12 +151,12 @@ void TestWorkload::WriteThread() {
     {
       for (int i = 0; i < write_batch_size_; i++) {
         if (write_pattern_ == UPDATE_ONE_ROW) {
-          gscoped_ptr<KuduUpdate> update(table->NewUpdate());
+          unique_ptr<KuduUpdate> update(table->NewUpdate());
           KuduPartialRow* row = update->mutable_row();
           GenerateDataForRow(schema_, 0, &rng_, row);
           CHECK_OK(session->Apply(update.release()));
         } else {
-          gscoped_ptr<KuduInsert> insert(table->NewInsert());
+          unique_ptr<KuduInsert> insert(table->NewInsert());
           KuduPartialRow* row = insert->mutable_row();
           int32_t key;
           if (write_pattern_ == INSERT_SEQUENTIAL_ROWS) {
@@ -196,7 +195,7 @@ void TestWorkload::WriteThread() {
     // Write delete row to cluster.
     if (write_pattern_ == INSERT_RANDOM_ROWS_WITH_DELETE) {
       for (auto key : keys) {
-        gscoped_ptr<KuduDelete> op(table->NewDelete());
+        unique_ptr<KuduDelete> op(table->NewDelete());
         KuduPartialRow* row = op->mutable_row();
         WriteValueToColumn(schema_, 0, key, row);
         CHECK_OK(session->Apply(op.release()));
@@ -314,7 +313,7 @@ void TestWorkload::Setup() {
     }
 
     // Create the table.
-    gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+    unique_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
     Status s = table_creator->table_name(table_name_)
diff --git a/src/kudu/integration-tests/ts_itest-base.cc b/src/kudu/integration-tests/ts_itest-base.cc
index ae5d60d..2013e5e 100644
--- a/src/kudu/integration-tests/ts_itest-base.cc
+++ b/src/kudu/integration-tests/ts_itest-base.cc
@@ -28,7 +28,6 @@
 #include <vector>
 
 #include <gflags/gflags.h>
-#include <gflags/gflags_declare.h>
 #include <glog/logging.h>
 #include <gtest/gtest.h>
 
@@ -73,6 +72,7 @@ using kudu::cluster::LocationInfo;
 using std::pair;
 using std::set;
 using std::string;
+using std::unique_ptr;
 using std::unordered_multimap;
 using std::unordered_set;
 using std::vector;
@@ -531,7 +531,7 @@ void TabletServerIntegrationTestBase::CreateTable(const string& table_id) {
   // The tests here make extensive use of server schemas, but we need
   // a client schema to create the table.
   client::KuduSchema client_schema(client::KuduSchema::FromSchema(schema_));
-  gscoped_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
+  unique_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
   ASSERT_OK(table_creator->table_name(table_id)
            .schema(&client_schema)
            .set_range_partition_columns({ "key" })
diff --git a/src/kudu/integration-tests/ts_itest-base.h b/src/kudu/integration-tests/ts_itest-base.h
index 1594a21..4270555 100644
--- a/src/kudu/integration-tests/ts_itest-base.h
+++ b/src/kudu/integration-tests/ts_itest-base.h
@@ -14,16 +14,15 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-
 #pragma once
 
 #include <cstdint>
+#include <memory>
 #include <string>
 #include <unordered_set>
 #include <vector>
 
 #include "kudu/client/shared_ptr.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/integration-tests/cluster_itest_util.h"
 #include "kudu/integration-tests/mini_cluster_fs_inspector.h"
 #include "kudu/mini-cluster/external_mini_cluster.h"
@@ -157,8 +156,8 @@ class TabletServerIntegrationTestBase : public TabletServerTestBase {
   std::vector<std::string> GetServersWithoutReplica(const std::string& tablet_id) const;
 
  protected:
-  gscoped_ptr<cluster::ExternalMiniCluster> cluster_;
-  gscoped_ptr<itest::MiniClusterFsInspector> inspect_;
+  std::unique_ptr<cluster::ExternalMiniCluster> cluster_;
+  std::unique_ptr<itest::MiniClusterFsInspector> inspect_;
 
   // Maps server uuid to TServerDetails
   itest::TabletServerMap tablet_servers_;
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 13d4970..f16af36 100644
--- a/src/kudu/integration-tests/update_scan_delta_compact-test.cc
+++ b/src/kudu/integration-tests/update_scan_delta_compact-test.cc
@@ -23,7 +23,6 @@
 #include <vector>
 
 #include <gflags/gflags.h>
-#include <gflags/gflags_declare.h>
 #include <glog/logging.h>
 #include <gtest/gtest.h>
 
@@ -35,7 +34,6 @@
 #include "kudu/client/shared_ptr.h"
 #include "kudu/client/write_op.h"
 #include "kudu/common/partial_row.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/strings/strcat.h"
@@ -81,6 +79,7 @@ using kudu::client::sp::shared_ptr;
 using kudu::cluster::InternalMiniCluster;
 using kudu::cluster::InternalMiniClusterOptions;
 using std::string;
+using std::unique_ptr;
 using std::vector;
 
 namespace kudu {
@@ -107,7 +106,7 @@ class UpdateScanDeltaCompactionTest : public KuduTest {
 
   void CreateTable() {
     NO_FATALS(InitCluster());
-    gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+    unique_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
     ASSERT_OK(table_creator->table_name(kTableName)
              .schema(&schema_)
              .set_range_partition_columns({ "key" })
@@ -210,7 +209,7 @@ void UpdateScanDeltaCompactionTest::InsertBaseData() {
 
   LOG_TIMING(INFO, "Insert") {
     for (int64_t key = 0; key < FLAGS_row_count; key++) {
-      gscoped_ptr<KuduInsert> insert(table_->NewInsert());
+      unique_ptr<KuduInsert> insert(table_->NewInsert());
       MakeRow(key, 0, insert->mutable_row());
       ASSERT_OK(session->Apply(insert.release()));
       ASSERT_OK(WaitForLastBatchAndFlush(key, &last_s, &last_s_cb, session));
@@ -272,7 +271,7 @@ void UpdateScanDeltaCompactionTest::UpdateRows(CountDownLatch* stop_latch) {
     last_s_cb.Run(Status::OK());
     LOG_TIMING(INFO, "Update") {
       for (int64_t key = 0; key < FLAGS_row_count && stop_latch->count() > 0; key++) {
-        gscoped_ptr<KuduUpdate> update(table_->NewUpdate());
+        unique_ptr<KuduUpdate> update(table_->NewUpdate());
         MakeRow(key, iteration, update->mutable_row());
         CHECK_OK(session->Apply(update.release()));
         CHECK_OK(WaitForLastBatchAndFlush(key, &last_s, &last_s_cb, session));
diff --git a/src/kudu/integration-tests/write_throttling-itest.cc b/src/kudu/integration-tests/write_throttling-itest.cc
index 3ce5344..f477c3a 100644
--- a/src/kudu/integration-tests/write_throttling-itest.cc
+++ b/src/kudu/integration-tests/write_throttling-itest.cc
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <memory>
 #include <ostream>
 #include <string>
 #include <vector>
@@ -28,31 +29,28 @@
 #include "kudu/client/shared_ptr.h"
 #include "kudu/client/write_op.h"
 #include "kudu/common/partial_row.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/integration-tests/external_mini_cluster-itest-base.h"
 #include "kudu/util/monotime.h"
 #include "kudu/util/status.h"
 #include "kudu/util/test_macros.h"
 
-using std::string;
-using std::vector;
-
 DEFINE_int32(throttling_test_time, 3,
              "Number of seconds to run write throttling test");
 
+using kudu::client::KuduColumnSchema;
+using kudu::client::KuduInsert;
+using kudu::client::KuduSchema;
+using kudu::client::KuduSchemaBuilder;
+using kudu::client::KuduSession;
+using kudu::client::KuduTable;
+using kudu::client::KuduTableCreator;
+using std::string;
+using std::unique_ptr;
+using std::vector;
+
 namespace kudu {
 namespace tablet {
 
-using client::KuduClient;
-using client::KuduClientBuilder;
-using client::KuduColumnSchema;
-using client::KuduInsert;
-using client::KuduSchema;
-using client::KuduSchemaBuilder;
-using client::KuduSession;
-using client::KuduTable;
-using client::KuduTableCreator;
-
 class WriteThrottlingTest : public ExternalMiniClusterITestBase {
  protected:
   WriteThrottlingTest() {
@@ -63,7 +61,7 @@ class WriteThrottlingTest : public ExternalMiniClusterITestBase {
   }
 
   void CreateTable() {
-    gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+    unique_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
     ASSERT_OK(table_creator->table_name(kTableName)
              .schema(&schema_)
              .set_range_partition_columns({ "key" })
@@ -96,7 +94,7 @@ TEST_F(WriteThrottlingTest, ThrottleWriteRpcPerSec) {
   for (int t = 0; t < FLAGS_throttling_test_time; t++) {
     MonoTime begin = MonoTime::Now();
     for (int i = 0; i < TARGET_QPS; i++) {
-      gscoped_ptr<KuduInsert> insert(table_->NewInsert());
+      unique_ptr<KuduInsert> insert(table_->NewInsert());
       KuduPartialRow* row = insert->mutable_row();
       CHECK_OK(row->SetInt64("key", t * TARGET_QPS + i));
       CHECK_OK(row->SetStringNoCopy("string_val", string_val));
@@ -128,7 +126,7 @@ TEST_F(WriteThrottlingTest, ThrottleWriteBytesPerSec) {
   for (int t = 0; t < FLAGS_throttling_test_time; t++) {
     MonoTime begin = MonoTime::Now();
     for (int i = 0; i < TARGET_QPS; i++) {
-      gscoped_ptr<KuduInsert> insert(table_->NewInsert());
+      unique_ptr<KuduInsert> insert(table_->NewInsert());
       KuduPartialRow* row = insert->mutable_row();
       CHECK_OK(row->SetInt64("key", t * TARGET_QPS + i));
       CHECK_OK(row->SetStringNoCopy("string_val", string_val));
diff --git a/src/kudu/kserver/kserver.cc b/src/kudu/kserver/kserver.cc
index c2b1db9..c645240 100644
--- a/src/kudu/kserver/kserver.cc
+++ b/src/kudu/kserver/kserver.cc
@@ -28,7 +28,6 @@
 #include <glog/logging.h>
 
 #include "kudu/fs/fs_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/strings/numbers.h"
 #include "kudu/gutil/strings/substitute.h"
diff --git a/src/kudu/master/catalog_manager.cc b/src/kudu/master/catalog_manager.cc
index 8a2d8a5..562516e 100644
--- a/src/kudu/master/catalog_manager.cc
+++ b/src/kudu/master/catalog_manager.cc
@@ -54,7 +54,6 @@
 #include <ostream>
 #include <set>
 #include <string>
-#include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
@@ -87,7 +86,6 @@
 #include "kudu/gutil/basictypes.h"
 #include "kudu/gutil/bind.h"
 #include "kudu/gutil/bind_helpers.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/port.h"
@@ -3168,7 +3166,7 @@ class PickLeaderReplica : public TSPicker {
 class RetryingTSRpcTask : public MonitoredTask {
  public:
   RetryingTSRpcTask(Master *master,
-                    gscoped_ptr<TSPicker> replica_picker,
+                    unique_ptr<TSPicker> replica_picker,
                     scoped_refptr<TableInfo> table)
     : master_(master),
       replica_picker_(std::move(replica_picker)),
@@ -3238,7 +3236,7 @@ class RetryingTSRpcTask : public MonitoredTask {
   void RpcCallback();
 
   Master * const master_;
-  const gscoped_ptr<TSPicker> replica_picker_;
+  const unique_ptr<TSPicker> replica_picker_;
   const scoped_refptr<TableInfo> table_;
 
   MonoTime start_ts_;
@@ -3413,7 +3411,7 @@ class RetrySpecificTSRpcTask : public RetryingTSRpcTask {
                          const string& permanent_uuid,
                          const scoped_refptr<TableInfo>& table)
     : RetryingTSRpcTask(master,
-                        gscoped_ptr<TSPicker>(new PickSpecificUUID(permanent_uuid)),
+                        unique_ptr<TSPicker>(new PickSpecificUUID(permanent_uuid)),
                         table),
       permanent_uuid_(permanent_uuid) {
   }
@@ -3606,7 +3604,7 @@ class AsyncAlterTable : public RetryingTSRpcTask {
   AsyncAlterTable(Master *master,
                   scoped_refptr<TabletInfo> tablet)
     : RetryingTSRpcTask(master,
-                        gscoped_ptr<TSPicker>(new PickLeaderReplica(tablet)),
+                        unique_ptr<TSPicker>(new PickLeaderReplica(tablet)),
                         tablet->table()),
       tablet_(std::move(tablet)) {
   }
@@ -3706,7 +3704,7 @@ AsyncChangeConfigTask::AsyncChangeConfigTask(Master* master,
                                              ConsensusStatePB cstate,
                                              consensus::ChangeConfigType change_config_type)
     : RetryingTSRpcTask(master,
-                        gscoped_ptr<TSPicker>(new PickLeaderReplica(tablet)),
+                        unique_ptr<TSPicker>(new PickLeaderReplica(tablet)),
                         tablet->table()),
       tablet_(std::move(tablet)),
       cstate_(std::move(cstate)),
diff --git a/src/kudu/master/master-test.cc b/src/kudu/master/master-test.cc
index 18bd30d..79bd17a 100644
--- a/src/kudu/master/master-test.cc
+++ b/src/kudu/master/master-test.cc
@@ -50,7 +50,6 @@
 #include "kudu/consensus/replica_management.pb.h"
 #include "kudu/generated/version_defines.h"
 #include "kudu/gutil/dynamic_annotations.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/strings/split.h"
@@ -103,6 +102,7 @@ using std::pair;
 using std::shared_ptr;
 using std::string;
 using std::thread;
+using std::unique_ptr;
 using std::unordered_map;
 using std::unordered_set;
 using std::vector;
@@ -161,9 +161,9 @@ class MasterTest : public KuduTest {
                      const vector<pair<KuduPartialRow, KuduPartialRow>>& bounds);
 
   shared_ptr<Messenger> client_messenger_;
-  gscoped_ptr<MiniMaster> mini_master_;
+  unique_ptr<MiniMaster> mini_master_;
   Master* master_;
-  gscoped_ptr<MasterServiceProxy> proxy_;
+  unique_ptr<MasterServiceProxy> proxy_;
 };
 
 TEST_F(MasterTest, TestPingServer) {
diff --git a/src/kudu/master/sys_catalog-test.cc b/src/kudu/master/sys_catalog-test.cc
index 6fbb942..a10349c 100644
--- a/src/kudu/master/sys_catalog-test.cc
+++ b/src/kudu/master/sys_catalog-test.cc
@@ -27,7 +27,6 @@
 #include "kudu/common/common.pb.h"
 #include "kudu/common/schema.h"
 #include "kudu/common/wire_protocol.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/master/catalog_manager.h"
 #include "kudu/master/master.h"
@@ -54,6 +53,7 @@ using kudu::security::DataFormat;
 using kudu::security::PrivateKey;
 using std::shared_ptr;
 using std::string;
+using std::unique_ptr;
 using std::vector;
 
 namespace google {
@@ -90,9 +90,9 @@ class SysCatalogTest : public KuduTest {
   }
 
   shared_ptr<Messenger> client_messenger_;
-  gscoped_ptr<MiniMaster> mini_master_;
+  unique_ptr<MiniMaster> mini_master_;
   Master* master_;
-  gscoped_ptr<MasterServiceProxy> proxy_;
+  unique_ptr<MasterServiceProxy> proxy_;
 };
 
 class TestTableLoader : public TableVisitor {
diff --git a/src/kudu/master/ts_descriptor.h b/src/kudu/master/ts_descriptor.h
index 9c4199a..5b8c8ee 100644
--- a/src/kudu/master/ts_descriptor.h
+++ b/src/kudu/master/ts_descriptor.h
@@ -14,8 +14,7 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef KUDU_MASTER_TS_DESCRIPTOR_H
-#define KUDU_MASTER_TS_DESCRIPTOR_H
+#pragma once
 
 #include <cstdint>
 #include <memory>
@@ -31,7 +30,6 @@
 
 #include "kudu/common/wire_protocol.pb.h"
 #include "kudu/gutil/basictypes.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/util/locks.h"
@@ -204,7 +202,7 @@ class TSDescriptor : public enable_make_shared<TSDescriptor> {
   // The tablet server's location, as determined by the master at registration.
   boost::optional<std::string> location_;
 
-  gscoped_ptr<ServerRegistrationPB> registration_;
+  std::unique_ptr<ServerRegistrationPB> registration_;
 
   std::shared_ptr<tserver::TabletServerAdminServiceProxy> ts_admin_proxy_;
   std::shared_ptr<consensus::ConsensusServiceProxy> consensus_proxy_;
@@ -218,4 +216,3 @@ typedef std::vector<std::shared_ptr<TSDescriptor>> TSDescriptorVector;
 
 } // namespace master
 } // namespace kudu
-#endif /* KUDU_MASTER_TS_DESCRIPTOR_H */
diff --git a/src/kudu/mini-cluster/internal_mini_cluster.cc b/src/kudu/mini-cluster/internal_mini_cluster.cc
index 80dd51c..830eb43 100644
--- a/src/kudu/mini-cluster/internal_mini_cluster.cc
+++ b/src/kudu/mini-cluster/internal_mini_cluster.cc
@@ -26,7 +26,6 @@
 #include "kudu/client/client.h"
 #include "kudu/common/wire_protocol.pb.h"
 #include "kudu/fs/fs_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/master/catalog_manager.h"
 #include "kudu/master/master.h"
@@ -199,9 +198,10 @@ Status InternalMiniCluster::AddTabletServer() {
   }
 
   string bind_ip = GetBindIpForDaemonWithType(MiniCluster::TSERVER, new_idx, opts_.bind_mode);
-  gscoped_ptr<MiniTabletServer> tablet_server(new MiniTabletServer(GetTabletServerFsRoot(new_idx),
-                                                                   HostPort(bind_ip, ts_rpc_port),
-                                                                   opts_.num_data_dirs));
+  unique_ptr<MiniTabletServer> tablet_server(new MiniTabletServer(
+      GetTabletServerFsRoot(new_idx),
+      HostPort(bind_ip, ts_rpc_port),
+      opts_.num_data_dirs));
 
   // set the master addresses
   tablet_server->options()->master_addresses = master_rpc_addrs();
diff --git a/src/kudu/rpc/connection.cc b/src/kudu/rpc/connection.cc
index 508cb35..7dc0c03 100644
--- a/src/kudu/rpc/connection.cc
+++ b/src/kudu/rpc/connection.cc
@@ -32,7 +32,6 @@
 #include <ev.h>
 #include <glog/logging.h>
 
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/strings/human_readable.h"
 #include "kudu/gutil/strings/substitute.h"
diff --git a/src/kudu/rpc/rpc-test.cc b/src/kudu/rpc/rpc-test.cc
index 4258de2..cb78577 100644
--- a/src/kudu/rpc/rpc-test.cc
+++ b/src/kudu/rpc/rpc-test.cc
@@ -34,7 +34,6 @@
 #include <gtest/gtest.h>
 
 #include "kudu/gutil/casts.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/stl_util.h"
@@ -1377,7 +1376,7 @@ TEST_P(TestRpc, TestCancellationAsync) {
   RpcController controller;
 
   // The payload to be used during the RPC.
-  gscoped_array<uint8_t> payload(new uint8_t[TEST_PAYLOAD_SIZE]);
+  unique_ptr<uint8_t[]> payload(new uint8_t[TEST_PAYLOAD_SIZE]);
 
   // Used to generate sleep time between invoking RPC and requesting cancellation.
   Random rand(SeedRandom());
diff --git a/src/kudu/server/glog_metrics.h b/src/kudu/server/glog_metrics.h
index 9a7bf32..e78f4f9 100644
--- a/src/kudu/server/glog_metrics.h
+++ b/src/kudu/server/glog_metrics.h
@@ -14,10 +14,10 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef KUDU_SERVER_GLOG_METRICS_H
-#define KUDU_SERVER_GLOG_METRICS_H
+#pragma once
+
+#include <memory>
 
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/ref_counted.h"
 
 namespace google {
@@ -38,14 +38,12 @@ class ScopedGLogMetrics {
   ~ScopedGLogMetrics();
 
  private:
-  gscoped_ptr<google::LogSink> sink_;
+  std::unique_ptr<google::LogSink> sink_;
 };
 
-
 // Registers glog-related metrics.
 // This can be called multiple times on different entities, though the resulting
 // metrics will be identical, since the GLog tracking is process-wide.
 void RegisterGLogMetrics(const scoped_refptr<MetricEntity>& entity);
 
 } // namespace kudu
-#endif /* KUDU_SERVER_GLOG_METRICS_H */
diff --git a/src/kudu/tablet/compaction-test.cc b/src/kudu/tablet/compaction-test.cc
index 974fa18..451e4a4 100644
--- a/src/kudu/tablet/compaction-test.cc
+++ b/src/kudu/tablet/compaction-test.cc
@@ -50,7 +50,6 @@
 #include "kudu/fs/fs_manager.h"
 #include "kudu/fs/log_block_manager.h"
 #include "kudu/gutil/casts.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/tablet/diskrowset.h"
@@ -310,13 +309,13 @@ class TestCompaction : public KuduRowSetTest {
     }
   }
 
-  Status BuildCompactionInput(const MvccSnapshot& merge_snap,
-                              const vector<shared_ptr<DiskRowSet> >& rowsets,
-                              const Schema& projection,
-                              gscoped_ptr<CompactionInput>* out) {
+  static Status BuildCompactionInput(const MvccSnapshot& merge_snap,
+                                     const vector<shared_ptr<DiskRowSet> >& rowsets,
+                                     const Schema& projection,
+                                     unique_ptr<CompactionInput>* out) {
     vector<shared_ptr<CompactionInput> > merge_inputs;
     for (const shared_ptr<DiskRowSet> &rs : rowsets) {
-      gscoped_ptr<CompactionInput> input;
+      unique_ptr<CompactionInput> input;
       RETURN_NOT_OK(CompactionInput::Create(*rs, &projection, merge_snap, nullptr, &input));
       merge_inputs.push_back(shared_ptr<CompactionInput>(input.release()));
     }
@@ -331,7 +330,7 @@ class TestCompaction : public KuduRowSetTest {
                           const Schema& projection, int64_t roll_threshold,
                           vector<shared_ptr<DiskRowSet> >* result_rowsets) {
     MvccSnapshot merge_snap(mvcc_);
-    gscoped_ptr<CompactionInput> compact_input;
+    unique_ptr<CompactionInput> compact_input;
     RETURN_NOT_OK(BuildCompactionInput(merge_snap, rowsets, projection, &compact_input));
     DoFlushAndReopen(compact_input.get(), projection, merge_snap, roll_threshold,
                      result_rowsets);
@@ -356,7 +355,7 @@ class TestCompaction : public KuduRowSetTest {
                          vector<shared_ptr<DiskRowSet> >* result_rowsets) {
     MvccSnapshot snap(mvcc_);
     vector<shared_ptr<RowSetMetadata> > rowset_metas;
-    gscoped_ptr<CompactionInput> input(CompactionInput::Create(mrs, &projection, snap));
+    unique_ptr<CompactionInput> input(CompactionInput::Create(mrs, &projection, snap));
     DoFlushAndReopen(input.get(), projection, snap, roll_threshold, result_rowsets);
   }
 
@@ -459,7 +458,7 @@ class TestCompaction : public KuduRowSetTest {
     LOG_TIMING(INFO, "compacting " +
                std::string((OVERLAP_INPUTS ? "with overlap" : "without overlap"))) {
       MvccSnapshot merge_snap(mvcc_);
-      gscoped_ptr<CompactionInput> compact_input;
+      unique_ptr<CompactionInput> compact_input;
       ASSERT_OK(BuildCompactionInput(merge_snap, rowsets, schema_, &compact_input));
       // Use a low target row size to increase the number of resulting rowsets.
       RollingDiskRowSetWriter rdrsw(tablet()->metadata(), schema_,
@@ -505,7 +504,7 @@ TEST_F(TestCompaction, TestMemRowSetInput) {
   // and mutations.
   vector<string> out;
   MvccSnapshot snap(mvcc_);
-  gscoped_ptr<CompactionInput> input(CompactionInput::Create(*mrs, &schema_, snap));
+  unique_ptr<CompactionInput> input(CompactionInput::Create(*mrs, &schema_, snap));
   IterateInput(input.get(), &out);
   ASSERT_EQ(10, out.size());
   EXPECT_EQ(R"(RowIdxInBlock: 0; Base: (string key="hello 00000000", int32 val=0, )"
@@ -569,7 +568,7 @@ TEST_F(TestCompaction, TestRowSetInput) {
 
   // Check compaction input
   vector<string> out;
-  gscoped_ptr<CompactionInput> input;
+  unique_ptr<CompactionInput> input;
   ASSERT_OK(CompactionInput::Create(*rs, &schema_, MvccSnapshot(mvcc_), nullptr, &input));
   IterateInput(input.get(), &out);
   ASSERT_EQ(10, out.size());
@@ -638,7 +637,7 @@ TEST_F(TestCompaction, TestDuplicatedGhostRowsMerging) {
   // Now compact all the drs and make sure we don't get duplicated keys on the output
   CompactAndReopenNoRoll(all_rss, schema_, &result);
 
-  gscoped_ptr<CompactionInput> input;
+  unique_ptr<CompactionInput> input;
   ASSERT_OK(CompactionInput::Create(*result,
                                     &schema_,
                                     MvccSnapshot::CreateSnapshotIncludingAllTransactions(),
@@ -803,7 +802,7 @@ TEST_F(TestCompaction, TestDuplicatedRowsRandomCompaction) {
 
   vector<shared_ptr<CompactionInput>> inputs;
   for (auto& row_set : row_sets) {
-    gscoped_ptr<CompactionInput> ci;
+    unique_ptr<CompactionInput> ci;
     CHECK_OK(row_set->NewCompactionInput(&schema_, all_snap, nullptr, &ci));
     inputs.push_back(shared_ptr<CompactionInput>(ci.release()));
   }
@@ -824,7 +823,7 @@ TEST_F(TestCompaction, TestDuplicatedRowsRandomCompaction) {
   }
 
   vector<string> out;
-  gscoped_ptr<CompactionInput> ci;
+  unique_ptr<CompactionInput> ci;
   CHECK_OK(row_sets[0]->NewCompactionInput(&schema_, all_snap, nullptr, &ci));
   IterateInput(ci.get(), &out);
 
@@ -873,17 +872,17 @@ TEST_F(TestCompaction, TestMRSCompactionDoesntOutputUnobservableRows) {
 
   MvccSnapshot all_snap = MvccSnapshot::CreateSnapshotIncludingAllTransactions();
 
-  gscoped_ptr<CompactionInput> rs1_input;
+  unique_ptr<CompactionInput> rs1_input;
   ASSERT_OK(CompactionInput::Create(*rs1, &schema_, all_snap, nullptr, &rs1_input));
 
-  gscoped_ptr<CompactionInput> rs2_input;
+  unique_ptr<CompactionInput> rs2_input;
   ASSERT_OK(CompactionInput::Create(*rs2, &schema_, all_snap, nullptr, &rs2_input));
 
   vector<shared_ptr<CompactionInput>> to_merge;
   to_merge.push_back(shared_ptr<CompactionInput>(rs1_input.release()));
   to_merge.push_back(shared_ptr<CompactionInput>(rs2_input.release()));
 
-  gscoped_ptr<CompactionInput> merged(CompactionInput::Merge(to_merge, &schema_));
+  unique_ptr<CompactionInput> merged(CompactionInput::Merge(to_merge, &schema_));
 
   // Make sure the unobservable version of the row that was inserted and deleted in the MRS
   // in the same transaction doesn't show up in the compaction input.
@@ -919,7 +918,7 @@ TEST_F(TestCompaction, TestOneToOne) {
 
   // Catch the updates that came in after the snapshot flush was made.
   MvccSnapshot snap2(mvcc_);
-  gscoped_ptr<CompactionInput> input(CompactionInput::Create(*mrs, &schema_, snap2));
+  unique_ptr<CompactionInput> input(CompactionInput::Create(*mrs, &schema_, snap2));
 
   // Add some more updates which come into the new rowset while the "reupdate" is happening.
   UpdateRows(rs.get(), 1000, 0, 3);
@@ -941,7 +940,7 @@ TEST_F(TestCompaction, TestOneToOne) {
 
   // And compact (1 input to 1 output)
   MvccSnapshot snap3(mvcc_);
-  gscoped_ptr<CompactionInput> compact_input;
+  unique_ptr<CompactionInput> compact_input;
   ASSERT_OK(CompactionInput::Create(*rs, &schema_, snap3, nullptr, &compact_input));
   DoFlushAndReopen(compact_input.get(), schema_, snap3, kLargeRollThreshold, nullptr);
 }
@@ -979,7 +978,7 @@ TEST_F(TestCompaction, TestKUDU102) {
         shared_ptr<CompactionInput>(CompactionInput::Create(*mrs, &schema_, snap2)));
   merge_inputs.push_back(
         shared_ptr<CompactionInput>(CompactionInput::Create(*mrs_b, &schema_, snap2)));
-  gscoped_ptr<CompactionInput> input(CompactionInput::Merge(merge_inputs, &schema_));
+  unique_ptr<CompactionInput> input(CompactionInput::Merge(merge_inputs, &schema_));
 
   string dummy_name = "";
 
@@ -1036,7 +1035,7 @@ TEST_F(TestCompaction, TestMergeMRS) {
         shared_ptr<CompactionInput>(CompactionInput::Create(*mrs_a, &schema_, snap)));
   merge_inputs.push_back(
         shared_ptr<CompactionInput>(CompactionInput::Create(*mrs_b, &schema_, snap)));
-  gscoped_ptr<CompactionInput> input(CompactionInput::Merge(merge_inputs, &schema_));
+  unique_ptr<CompactionInput> input(CompactionInput::Merge(merge_inputs, &schema_));
 
   vector<string> out;
   IterateInput(input.get(), &out);
diff --git a/src/kudu/tablet/compaction.cc b/src/kudu/tablet/compaction.cc
index ecebbf8..1550447 100644
--- a/src/kudu/tablet/compaction.cc
+++ b/src/kudu/tablet/compaction.cc
@@ -179,7 +179,7 @@ class MemRowSetCompactionInput : public CompactionInput {
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MemRowSetCompactionInput);
-  gscoped_ptr<RowBlock> row_block_;
+  unique_ptr<RowBlock> row_block_;
 
   unique_ptr<MemRowSet::Iterator> iter_;
 
@@ -415,7 +415,7 @@ class MergeCompactionInput : public CompactionInput {
     : schema_(schema),
       num_dup_rows_(0) {
     for (const shared_ptr<CompactionInput> &input : inputs) {
-      gscoped_ptr<MergeState> state(new MergeState);
+      unique_ptr<MergeState> state(new MergeState);
       state->input = input;
       states_.push_back(state.release());
     }
@@ -850,7 +850,7 @@ Status CompactionInput::Create(const DiskRowSet &rowset,
                                const Schema* projection,
                                const MvccSnapshot &snap,
                                const IOContext* io_context,
-                               gscoped_ptr<CompactionInput>* out) {
+                               unique_ptr<CompactionInput>* out) {
   CHECK(projection->has_column_ids());
 
   unique_ptr<ColumnwiseIterator> base_cwise(rowset.base_data_->NewIterator(projection, io_context));
@@ -902,7 +902,7 @@ Status RowSetsInCompaction::CreateCompactionInput(const MvccSnapshot &snap,
 
   vector<shared_ptr<CompactionInput> > inputs;
   for (const shared_ptr<RowSet> &rs : rowsets_) {
-    gscoped_ptr<CompactionInput> input;
+    unique_ptr<CompactionInput> input;
     RETURN_NOT_OK_PREPEND(rs->NewCompactionInput(schema, snap, io_context, &input),
                           Substitute("Could not create compaction input for rowset $0",
                                      rs->ToString()));
@@ -910,7 +910,7 @@ Status RowSetsInCompaction::CreateCompactionInput(const MvccSnapshot &snap,
   }
 
   if (inputs.size() == 1) {
-    out->swap(inputs[0]);
+    *out = std::move(inputs[0]);
   } else {
     out->reset(CompactionInput::Merge(inputs, schema));
   }
@@ -1315,7 +1315,7 @@ Status ReupdateMissedDeltas(const IOContext* io_context,
         }
 
         DeltaTracker* cur_tracker = cur_drs->delta_tracker();
-        gscoped_ptr<OperationResultPB> result(new OperationResultPB);
+        unique_ptr<OperationResultPB> result(new OperationResultPB);
         DCHECK_LT(idx_in_delta_tracker, num_rows);
         Status s = cur_tracker->Update(mut->timestamp(),
                                        idx_in_delta_tracker,
diff --git a/src/kudu/tablet/compaction.h b/src/kudu/tablet/compaction.h
index e6fc30a..0c101c1 100644
--- a/src/kudu/tablet/compaction.h
+++ b/src/kudu/tablet/compaction.h
@@ -14,8 +14,7 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef KUDU_TABLET_COMPACTION_H
-#define KUDU_TABLET_COMPACTION_H
+#pragma once
 
 #include <cstddef>
 #include <memory>
@@ -28,7 +27,6 @@
 
 #include "kudu/common/rowblock.h"
 #include "kudu/common/timestamp.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/tablet/rowset.h"
 #include "kudu/util/status.h"
 
@@ -109,7 +107,7 @@ class CompactionInput {
                        const Schema* projection,
                        const MvccSnapshot &snap,
                        const fs::IOContext* io_context,
-                       gscoped_ptr<CompactionInput>* out);
+                       std::unique_ptr<CompactionInput>* out);
 
   // Create an input which reads from the given memrowset, yielding base rows and updates
   // prior to the given snapshot.
@@ -262,5 +260,3 @@ std::string CompactionInputRowToString(const CompactionInputRow& input_row);
 
 } // namespace tablet
 } // namespace kudu
-
-#endif
diff --git a/src/kudu/tablet/delta_compaction-test.cc b/src/kudu/tablet/delta_compaction-test.cc
index 2d7fa51..a602b11 100644
--- a/src/kudu/tablet/delta_compaction-test.cc
+++ b/src/kudu/tablet/delta_compaction-test.cc
@@ -36,7 +36,6 @@
 #include "kudu/fs/block_id.h"
 #include "kudu/fs/block_manager.h"
 #include "kudu/fs/fs_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/tablet/delta_iterator_merger.h"
 #include "kudu/tablet/delta_key.h"
@@ -79,7 +78,7 @@ class TestDeltaCompaction : public KuduTest {
     return builder.Build();
   }
 
-  Status GetDeltaFileWriter(gscoped_ptr<DeltaFileWriter>* dfw,
+  Status GetDeltaFileWriter(unique_ptr<DeltaFileWriter>* dfw,
                             BlockId* block_id) const {
     unique_ptr<WritableBlock> block;
     RETURN_NOT_OK(fs_manager_->CreateNewBlock({}, &block));
@@ -108,7 +107,7 @@ class TestDeltaCompaction : public KuduTest {
  protected:
   int64_t deltafile_idx_;
   Schema schema_;
-  gscoped_ptr<FsManager> fs_manager_;
+  unique_ptr<FsManager> fs_manager_;
 };
 
 TEST_F(TestDeltaCompaction, TestMergeMultipleSchemas) {
@@ -135,7 +134,7 @@ TEST_F(TestDeltaCompaction, TestMergeMultipleSchemas) {
   for (const Schema& schema : schemas) {
     // Write the Deltas
     BlockId block_id;
-    gscoped_ptr<DeltaFileWriter> dfw;
+    unique_ptr<DeltaFileWriter> dfw;
     ASSERT_OK(GetDeltaFileWriter(&dfw, &block_id));
 
     // Generate N updates with the new schema, some of them are on existing
@@ -200,7 +199,7 @@ TEST_F(TestDeltaCompaction, TestMergeMultipleSchemas) {
   opts.projection = &merge_schema;
   unique_ptr<DeltaIterator> merge_iter;
   ASSERT_OK(DeltaIteratorMerger::Create(inputs, opts, &merge_iter));
-  gscoped_ptr<DeltaFileWriter> dfw;
+  unique_ptr<DeltaFileWriter> dfw;
   BlockId block_id;
   ASSERT_OK(GetDeltaFileWriter(&dfw, &block_id));
   ASSERT_OK(WriteDeltaIteratorToFile<REDO>(merge_iter.get(),
diff --git a/src/kudu/tablet/delta_compaction.cc b/src/kudu/tablet/delta_compaction.cc
index d6dbb9e..21eefdd 100644
--- a/src/kudu/tablet/delta_compaction.cc
+++ b/src/kudu/tablet/delta_compaction.cc
@@ -52,22 +52,19 @@
 #include "kudu/util/memory/arena.h"
 #include "kudu/util/trace.h"
 
+using kudu::fs::BlockCreationTransaction;
+using kudu::fs::BlockManager;
+using kudu::fs::CreateBlockOptions;
+using kudu::fs::IOContext;
+using kudu::fs::WritableBlock;
 using std::shared_ptr;
-
-namespace kudu {
-
-using fs::BlockCreationTransaction;
-using fs::BlockManager;
-using fs::CreateBlockOptions;
-using fs::IOContext;
-using fs::WritableBlock;
 using std::string;
 using std::unique_ptr;
 using std::vector;
 using strings::Substitute;
 
+namespace kudu {
 namespace tablet {
-
 namespace {
 
 const size_t kRowsPerBlock = 100; // Number of rows per block of columns
@@ -267,11 +264,11 @@ Status MajorDeltaCompaction::FlushRowSetAndDeltas(const IOContext* io_context) {
 Status MajorDeltaCompaction::OpenBaseDataWriter() {
   CHECK(!base_data_writer_);
 
-  gscoped_ptr<MultiColumnWriter> w(new MultiColumnWriter(fs_manager_,
-                                                         &partial_schema_,
-                                                         tablet_id_));
+  unique_ptr<MultiColumnWriter> w(new MultiColumnWriter(fs_manager_,
+                                                        &partial_schema_,
+                                                        tablet_id_));
   RETURN_NOT_OK(w->Open());
-  base_data_writer_.swap(w);
+  base_data_writer_ = std::move(w);
   return Status::OK();
 }
 
diff --git a/src/kudu/tablet/delta_compaction.h b/src/kudu/tablet/delta_compaction.h
index f790504..9bc5caa 100644
--- a/src/kudu/tablet/delta_compaction.h
+++ b/src/kudu/tablet/delta_compaction.h
@@ -14,8 +14,7 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef KUDU_TABLET_DELTA_COMPACTION_H
-#define KUDU_TABLET_DELTA_COMPACTION_H
+#pragma once
 
 #include <cstddef>
 #include <memory>
@@ -24,7 +23,6 @@
 
 #include "kudu/common/schema.h"
 #include "kudu/fs/block_id.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/tablet/compaction.h"
 #include "kudu/tablet/delta_store.h"
 #include "kudu/util/status.h"
@@ -129,12 +127,12 @@ class MajorDeltaCompaction {
   const std::string tablet_id_;
 
   // Outputs:
-  gscoped_ptr<MultiColumnWriter> base_data_writer_;
+  std::unique_ptr<MultiColumnWriter> base_data_writer_;
   // The following two may not be initialized if we don't need to write a delta file.
-  gscoped_ptr<DeltaFileWriter> new_redo_delta_writer_;
+  std::unique_ptr<DeltaFileWriter> new_redo_delta_writer_;
   BlockId new_redo_delta_block_;
 
-  gscoped_ptr<DeltaFileWriter> new_undo_delta_writer_;
+  std::unique_ptr<DeltaFileWriter> new_undo_delta_writer_;
   BlockId new_undo_delta_block_;
 
   size_t redo_delta_mutations_written_;
@@ -149,5 +147,3 @@ class MajorDeltaCompaction {
 
 } // namespace tablet
 } // namespace kudu
-
-#endif
diff --git a/src/kudu/tablet/delta_tracker.cc b/src/kudu/tablet/delta_tracker.cc
index 0c0b0d7..00d47d7 100644
--- a/src/kudu/tablet/delta_tracker.cc
+++ b/src/kudu/tablet/delta_tracker.cc
@@ -77,13 +77,13 @@ Status DeltaTracker::Open(const shared_ptr<RowSetMetadata>& rowset_metadata,
                           LogAnchorRegistry* log_anchor_registry,
                           const TabletMemTrackers& mem_trackers,
                           const IOContext* io_context,
-                          gscoped_ptr<DeltaTracker>* delta_tracker) {
-  gscoped_ptr<DeltaTracker> local_dt(
+                          unique_ptr<DeltaTracker>* delta_tracker) {
+  unique_ptr<DeltaTracker> local_dt(
       new DeltaTracker(rowset_metadata, log_anchor_registry,
                        mem_trackers));
   RETURN_NOT_OK(local_dt->DoOpen(io_context));
 
-  delta_tracker->swap(local_dt);
+  *delta_tracker = std::move(local_dt);
   return Status::OK();
 }
 
@@ -166,7 +166,7 @@ Status DeltaTracker::CreateAndInitDMSUnlocked(const fs::IOContext* io_context) {
                                       &dms));
   RETURN_NOT_OK(dms->Init(io_context));
 
-  dms_.swap(dms);
+  dms_ = std::move(dms);
   dms_exists_.Store(true);
   return Status::OK();
 }
@@ -718,7 +718,7 @@ Status DeltaTracker::FlushDMS(DeltaMemStore* dms,
                         Substitute("Unable to start writing to delta block $0",
                                    block_id.ToString()));
 
-  gscoped_ptr<DeltaStats> stats;
+  unique_ptr<DeltaStats> stats;
   RETURN_NOT_OK(dms->FlushToFile(&dfw, &stats));
   RETURN_NOT_OK(dfw.Finish());
   const auto bytes_written = dfw.written_size();
@@ -779,7 +779,7 @@ Status DeltaTracker::Flush(const IOContext* io_context, MetadataFlushType flush_
     count = dms_exists_.Load() ? dms_->Count() : 0;
 
     // Swap the DeltaMemStore and dms_ is null now.
-    old_dms.swap(dms_);
+    old_dms = std::move(dms_);
     dms_exists_.Store(false);
 
     if (count == 0) {
diff --git a/src/kudu/tablet/delta_tracker.h b/src/kudu/tablet/delta_tracker.h
index a4ea0a1..5ae97a2 100644
--- a/src/kudu/tablet/delta_tracker.h
+++ b/src/kudu/tablet/delta_tracker.h
@@ -14,8 +14,7 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef KUDU_TABLET_DELTATRACKER_H
-#define KUDU_TABLET_DELTATRACKER_H
+#pragma once
 
 #include <cstddef>
 #include <cstdint>
@@ -26,7 +25,6 @@
 #include <gtest/gtest_prod.h>
 
 #include "kudu/common/rowid.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/tablet/cfile_set.h"
 #include "kudu/tablet/delta_key.h"
@@ -87,7 +85,7 @@ class DeltaTracker {
                      log::LogAnchorRegistry* log_anchor_registry,
                      const TabletMemTrackers& mem_trackers,
                      const fs::IOContext* io_context,
-                     gscoped_ptr<DeltaTracker>* delta_tracker);
+                     std::unique_ptr<DeltaTracker>* delta_tracker);
 
   Status WrapIterator(const std::shared_ptr<CFileSet::Iterator> &base,
                       const RowIteratorOptions& opts,
@@ -384,5 +382,3 @@ class DeltaTracker {
 
 } // namespace tablet
 } // namespace kudu
-
-#endif
diff --git a/src/kudu/tablet/deltafile.cc b/src/kudu/tablet/deltafile.cc
index 26a3495..227429a 100644
--- a/src/kudu/tablet/deltafile.cc
+++ b/src/kudu/tablet/deltafile.cc
@@ -24,7 +24,6 @@
 
 #include <boost/optional/optional.hpp>
 #include <gflags/gflags.h>
-#include <gflags/gflags_declare.h>
 
 #include "kudu/cfile/binary_plain_block.h"
 #include "kudu/cfile/cfile_reader.h"
@@ -41,7 +40,6 @@
 #include "kudu/fs/block_id.h"
 #include "kudu/fs/block_manager.h"
 #include "kudu/fs/fs_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/stringprintf.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/tablet/delta_relevancy.h"
@@ -235,7 +233,7 @@ Status DeltaFileReader::OpenNoInit(unique_ptr<ReadableBlock> block,
   RETURN_NOT_OK(CFileReader::OpenNoInit(std::move(block),
                                         std::move(options),
                                         &cf_reader));
-  gscoped_ptr<DeltaFileReader> df_reader(
+  unique_ptr<DeltaFileReader> df_reader(
       new DeltaFileReader(std::move(cf_reader), delta_type));
   if (!FLAGS_cfile_lazy_open) {
     RETURN_NOT_OK(df_reader->Init(io_context));
@@ -280,9 +278,9 @@ Status DeltaFileReader::ReadDeltaStats() {
   if (!deltastats_pb.ParseFromString(filestats_pb_buf)) {
     return Status::Corruption("unable to parse the delta stats protobuf");
   }
-  gscoped_ptr<DeltaStats>stats(new DeltaStats());
+  unique_ptr<DeltaStats> stats(new DeltaStats());
   RETURN_NOT_OK(stats->InitFromPB(deltastats_pb));
-  delta_stats_.swap(stats);
+  delta_stats_ = std::move(stats);
   return Status::OK();
 }
 
diff --git a/src/kudu/tablet/deltafile.h b/src/kudu/tablet/deltafile.h
index 56632ff..68222be 100644
--- a/src/kudu/tablet/deltafile.h
+++ b/src/kudu/tablet/deltafile.h
@@ -14,8 +14,7 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef KUDU_TABLET_DELTAFILE_H
-#define KUDU_TABLET_DELTAFILE_H
+#pragma once
 
 #include <cstddef>
 #include <cstdint>
@@ -32,7 +31,6 @@
 #include "kudu/cfile/cfile_reader.h"
 #include "kudu/cfile/cfile_writer.h"
 #include "kudu/common/rowid.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -211,7 +209,7 @@ class DeltaFileReader : public DeltaStore,
   Status ReadDeltaStats();
 
   std::shared_ptr<cfile::CFileReader> reader_;
-  gscoped_ptr<DeltaStats> delta_stats_;
+  std::unique_ptr<DeltaStats> delta_stats_;
 
   // The type of this delta, i.e. UNDO or REDO.
   const DeltaType delta_type_;
@@ -269,7 +267,7 @@ class DeltaFileIterator : public DeltaIterator {
 
     // The block decoder, to avoid having to re-parse the block header
     // on every ApplyUpdates() call
-    gscoped_ptr<cfile::BinaryPlainBlockDecoder> decoder_;
+    std::unique_ptr<cfile::BinaryPlainBlockDecoder> decoder_;
 
     // The first row index for which there is an update in this delta block.
     rowid_t first_updated_idx_;
@@ -318,7 +316,7 @@ class DeltaFileIterator : public DeltaIterator {
 
   DeltaPreparer<DeltaFilePreparerTraits<Type>> preparer_;
 
-  gscoped_ptr<cfile::IndexTreeIterator> index_iter_;
+  std::unique_ptr<cfile::IndexTreeIterator> index_iter_;
 
   bool prepared_;
   bool exhausted_;
@@ -337,5 +335,3 @@ class DeltaFileIterator : public DeltaIterator {
 
 } // namespace tablet
 } // namespace kudu
-
-#endif
diff --git a/src/kudu/tablet/deltamemstore-test.cc b/src/kudu/tablet/deltamemstore-test.cc
index 5fde7c4..51099e5 100644
--- a/src/kudu/tablet/deltamemstore-test.cc
+++ b/src/kudu/tablet/deltamemstore-test.cc
@@ -48,7 +48,6 @@
 #include "kudu/consensus/opid_util.h"
 #include "kudu/fs/block_manager.h"
 #include "kudu/fs/fs_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/tablet/delta_key.h"
 #include "kudu/tablet/delta_stats.h"
@@ -212,7 +211,7 @@ TEST_F(TestDeltaMemStore, TestUpdateCount) {
   ASSERT_OK(fs.CreateNewBlock({}, &block));
   DeltaFileWriter dfw(std::move(block));
   ASSERT_OK(dfw.Start());
-  gscoped_ptr<DeltaStats> stats;
+  unique_ptr<DeltaStats> stats;
   dms_->FlushToFile(&dfw, &stats);
 
   ASSERT_EQ(n_rows / 2, stats->update_count_for_col_id(schema_.column_id(kIntColumn)));
diff --git a/src/kudu/tablet/deltamemstore.cc b/src/kudu/tablet/deltamemstore.cc
index e356655..b78a108 100644
--- a/src/kudu/tablet/deltamemstore.cc
+++ b/src/kudu/tablet/deltamemstore.cc
@@ -127,13 +127,14 @@ Status DeltaMemStore::Update(Timestamp timestamp,
 }
 
 Status DeltaMemStore::FlushToFile(DeltaFileWriter *dfw,
-                                  gscoped_ptr<DeltaStats>* stats_ret) {
-  gscoped_ptr<DeltaStats> stats(new DeltaStats());
+                                  unique_ptr<DeltaStats>* stats_ret) {
+  unique_ptr<DeltaStats> stats(new DeltaStats());
 
-  gscoped_ptr<DMSTreeIter> iter(tree_.NewIterator());
+  unique_ptr<DMSTreeIter> iter(tree_.NewIterator());
   iter->SeekToStart();
   while (iter->IsValid()) {
-    Slice key_slice, val;
+    Slice key_slice;
+    Slice val;
     iter->GetCurrentEntry(&key_slice, &val);
     DeltaKey key;
     RETURN_NOT_OK(key.DecodeFrom(&key_slice));
@@ -165,7 +166,7 @@ Status DeltaMemStore::CheckRowDeleted(rowid_t row_idx,
 
   bool exact;
 
-  gscoped_ptr<DMSTreeIter> iter(tree_.NewIterator());
+  unique_ptr<DMSTreeIter> iter(tree_.NewIterator());
   if (!iter->SeekAtOrBefore(key_slice, &exact)) {
     return Status::OK();
   }
diff --git a/src/kudu/tablet/deltamemstore.h b/src/kudu/tablet/deltamemstore.h
index 687f45e..e287b68 100644
--- a/src/kudu/tablet/deltamemstore.h
+++ b/src/kudu/tablet/deltamemstore.h
@@ -14,8 +14,7 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef KUDU_TABLET_DELTAMEMSTORE_H
-#define KUDU_TABLET_DELTAMEMSTORE_H
+#pragma once
 
 #include <cstddef>
 #include <cstdint>
@@ -26,7 +25,6 @@
 #include "kudu/common/rowid.h"
 #include "kudu/consensus/log_anchor_registry.h"
 #include "kudu/gutil/atomicops.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/port.h"
 #include "kudu/tablet/concurrent_btree.h"
@@ -105,7 +103,7 @@ class DeltaMemStore : public DeltaStore,
   // Flush the DMS to the given file writer.
   // Returns statistics in *stats.
   Status FlushToFile(DeltaFileWriter *dfw,
-                     gscoped_ptr<DeltaStats>* stats);
+                     std::unique_ptr<DeltaStats>* stats);
 
   // Create an iterator for applying deltas from this DMS.
   //
@@ -241,7 +239,7 @@ class DMSIterator : public DeltaIterator {
 
   DeltaPreparer<DMSPreparerTraits> preparer_;
 
-  gscoped_ptr<DeltaMemStore::DMSTreeIter> iter_;
+  std::unique_ptr<DeltaMemStore::DMSTreeIter> iter_;
 
   bool initted_;
 
@@ -251,5 +249,3 @@ class DMSIterator : public DeltaIterator {
 
 } // namespace tablet
 } // namespace kudu
-
-#endif
diff --git a/src/kudu/tablet/diskrowset-test.cc b/src/kudu/tablet/diskrowset-test.cc
index bc6f3f7..947c5a5 100644
--- a/src/kudu/tablet/diskrowset-test.cc
+++ b/src/kudu/tablet/diskrowset-test.cc
@@ -46,7 +46,6 @@
 #include "kudu/consensus/opid_util.h"
 #include "kudu/fs/block_id.h"
 #include "kudu/fs/io_context.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/stringprintf.h"
 #include "kudu/gutil/strings/stringpiece.h"
diff --git a/src/kudu/tablet/diskrowset.cc b/src/kudu/tablet/diskrowset.cc
index 64ec1e1..e7c3d59 100644
--- a/src/kudu/tablet/diskrowset.cc
+++ b/src/kudu/tablet/diskrowset.cc
@@ -39,7 +39,6 @@
 #include "kudu/common/types.h"
 #include "kudu/fs/block_manager.h"
 #include "kudu/fs/fs_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/tablet/cfile_set.h"
 #include "kudu/tablet/compaction.h"
@@ -368,8 +367,8 @@ Status RollingDiskRowSetWriter::RollWriter() {
   cur_redo_ds_block_id_ = redo_data_block->id();
   cur_undo_writer_.reset(new DeltaFileWriter(std::move(undo_data_block)));
   cur_redo_writer_.reset(new DeltaFileWriter(std::move(redo_data_block)));
-  cur_undo_delta_stats.reset(new DeltaStats());
-  cur_redo_delta_stats.reset(new DeltaStats());
+  cur_undo_delta_stats_.reset(new DeltaStats());
+  cur_redo_delta_stats_.reset(new DeltaStats());
 
   row_idx_in_cur_drs_ = 0;
   can_roll_ = false;
@@ -403,7 +402,7 @@ Status RollingDiskRowSetWriter::AppendUndoDeltas(rowid_t row_idx_in_block,
   return AppendDeltas<UNDO>(row_idx_in_block, undo_delta_head,
                             row_idx,
                             cur_undo_writer_.get(),
-                            cur_undo_delta_stats.get());
+                            cur_undo_delta_stats_.get());
 }
 
 Status RollingDiskRowSetWriter::AppendRedoDeltas(rowid_t row_idx_in_block,
@@ -412,7 +411,7 @@ Status RollingDiskRowSetWriter::AppendRedoDeltas(rowid_t row_idx_in_block,
   return AppendDeltas<REDO>(row_idx_in_block, redo_delta_head,
                             row_idx,
                             cur_redo_writer_.get(),
-                            cur_redo_delta_stats.get());
+                            cur_redo_delta_stats_.get());
 }
 
 template<DeltaType Type>
@@ -450,8 +449,8 @@ Status RollingDiskRowSetWriter::FinishCurrentWriter() {
     RETURN_NOT_OK(writer_status);
     CHECK_GT(cur_writer_->written_count(), 0);
 
-    cur_undo_writer_->WriteDeltaStats(*cur_undo_delta_stats);
-    cur_redo_writer_->WriteDeltaStats(*cur_redo_delta_stats);
+    cur_undo_writer_->WriteDeltaStats(*cur_undo_delta_stats_);
+    cur_redo_writer_->WriteDeltaStats(*cur_redo_delta_stats_);
 
     // Commit the UNDO block. Status::Aborted() indicates that there
     // were no UNDOs written.
@@ -460,7 +459,7 @@ Status RollingDiskRowSetWriter::FinishCurrentWriter() {
       RETURN_NOT_OK(s);
       cur_drs_metadata_->CommitUndoDeltaDataBlock(cur_undo_ds_block_id_);
     } else {
-      DCHECK_EQ(cur_undo_delta_stats->min_timestamp(), Timestamp::kMax);
+      DCHECK_EQ(cur_undo_delta_stats_->min_timestamp(), Timestamp::kMax);
     }
 
     // Same for the REDO block.
@@ -469,7 +468,7 @@ Status RollingDiskRowSetWriter::FinishCurrentWriter() {
       RETURN_NOT_OK(s);
       cur_drs_metadata_->CommitRedoDeltaDataBlock(0, 0, cur_redo_ds_block_id_);
     } else {
-      DCHECK_EQ(cur_redo_delta_stats->min_timestamp(), Timestamp::kMax);
+      DCHECK_EQ(cur_redo_delta_stats_->min_timestamp(), Timestamp::kMax);
     }
 
     written_size_ += cur_writer_->written_size();
@@ -583,7 +582,7 @@ Status DiskRowSet::MajorCompactDeltaStoresWithColumnIds(const vector<ColumnId>&
   RETURN_NOT_OK(delta_tracker()->CheckWritableUnlocked());
 
   // TODO(todd): do we need to lock schema or anything here?
-  gscoped_ptr<MajorDeltaCompaction> compaction;
+  unique_ptr<MajorDeltaCompaction> compaction;
   RETURN_NOT_OK(NewMajorDeltaCompaction(col_ids, std::move(history_gc_opts),
                                         io_context, &compaction));
 
@@ -633,7 +632,7 @@ Status DiskRowSet::MajorCompactDeltaStoresWithColumnIds(const vector<ColumnId>&
 Status DiskRowSet::NewMajorDeltaCompaction(const vector<ColumnId>& col_ids,
                                            HistoryGcOpts history_gc_opts,
                                            const IOContext* io_context,
-                                           gscoped_ptr<MajorDeltaCompaction>* out) const {
+                                           unique_ptr<MajorDeltaCompaction>* out) const {
   DCHECK(open_);
   shared_lock<rw_spinlock> l(component_lock_);
 
@@ -675,7 +674,7 @@ Status DiskRowSet::NewRowIterator(const RowIteratorOptions& opts,
 Status DiskRowSet::NewCompactionInput(const Schema* projection,
                                       const MvccSnapshot &snap,
                                       const IOContext* io_context,
-                                      gscoped_ptr<CompactionInput>* out) const {
+                                      unique_ptr<CompactionInput>* out) const {
   return CompactionInput::Create(*this, projection, snap, io_context, out);
 }
 
@@ -895,7 +894,7 @@ Status DiskRowSet::DeleteAncientUndoDeltas(Timestamp ancient_history_mark,
 Status DiskRowSet::DebugDump(vector<string> *lines) {
   // Using CompactionInput to dump our data is an easy way of seeing all the
   // rows and deltas.
-  gscoped_ptr<CompactionInput> input;
+  unique_ptr<CompactionInput> input;
   RETURN_NOT_OK(NewCompactionInput(&rowset_metadata_->tablet_schema(),
                                    MvccSnapshot::CreateSnapshotIncludingAllTransactions(),
                                    nullptr, &input));
diff --git a/src/kudu/tablet/diskrowset.h b/src/kudu/tablet/diskrowset.h
index 52689a4..045826b 100644
--- a/src/kudu/tablet/diskrowset.h
+++ b/src/kudu/tablet/diskrowset.h
@@ -35,7 +35,6 @@
 #include "kudu/common/schema.h"
 #include "kudu/fs/block_id.h"
 #include "kudu/fs/fs_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/tablet/delta_key.h"
@@ -147,9 +146,9 @@ class DiskRowSetWriter {
 
   bool finished_;
   rowid_t written_count_;
-  gscoped_ptr<MultiColumnWriter> col_writer_;
-  gscoped_ptr<cfile::BloomFileWriter> bloom_writer_;
-  gscoped_ptr<cfile::CFileWriter> ad_hoc_index_writer_;
+  std::unique_ptr<MultiColumnWriter> col_writer_;
+  std::unique_ptr<cfile::BloomFileWriter> bloom_writer_;
+  std::unique_ptr<cfile::CFileWriter> ad_hoc_index_writer_;
 
   // The last encoded key written.
   faststring last_encoded_key_;
@@ -184,20 +183,20 @@ class RollingDiskRowSetWriter {
   // 'live_row_count' means the number of live rows in this input block.
   Status AppendBlock(const RowBlock &block, int live_row_count = 0);
 
-  // Appends a sequence of REDO deltas for the same row to the current
-  // redo delta file. 'row_idx_in_next_block' is the positional index after
-  // the last written block. The 'row_idx_in_drs' out parameter will be set
-  // with the row index from the start of the DiskRowSet currently being written.
-  Status AppendRedoDeltas(rowid_t row_idx_in_next_block,
-                          Mutation* redo_deltas,
+  // Appends a sequence of REDO deltas for the same row to the current redo
+  // delta file. 'row_idx_in_block' is the positional index after the last
+  // written block. The 'row_idx_in_drs' out parameter will be set with the row
+  // index from the start of the DiskRowSet currently being written.
+  Status AppendRedoDeltas(rowid_t row_idx_in_block,
+                          Mutation* redo_delta_head,
                           rowid_t* row_idx_in_drs);
 
-  // Appends a sequence of UNDO deltas for the same row to the current
-  // undo delta file. 'row_idx_in_next_block' is the positional index after
-  // the last written block. The 'row_idx_in_drs' out parameter will be set
-  // with the row index from the start of the DiskRowSet currently being written.
-  Status AppendUndoDeltas(rowid_t row_idx_in_next_block,
-                          Mutation* undo_deltas,
+  // Appends a sequence of UNDO deltas for the same row to the current undo
+  // delta file. 'row_idx_in_block' is the positional index after the last
+  // written block. The 'row_idx_in_drs' out parameter will be set with the row
+  // index from the start of the DiskRowSet currently being written.
+  Status AppendUndoDeltas(rowid_t row_idx_in_block,
+                          Mutation* undo_delta_head,
                           rowid_t* row_idx_in_drs);
 
   // Try to roll the output, if we've passed the configured threshold. This will
@@ -248,14 +247,14 @@ class RollingDiskRowSetWriter {
   const BloomFilterSizing bloom_sizing_;
   const size_t target_rowset_size_;
 
-  gscoped_ptr<DiskRowSetWriter> cur_writer_;
+  std::unique_ptr<DiskRowSetWriter> cur_writer_;
 
   // A delta writer to store the undos for each DRS
-  gscoped_ptr<DeltaFileWriter> cur_undo_writer_;
-  gscoped_ptr<DeltaStats> cur_undo_delta_stats;
+  std::unique_ptr<DeltaFileWriter> cur_undo_writer_;
+  std::unique_ptr<DeltaStats> cur_undo_delta_stats_;
   // a delta writer to store the redos for each DRS
-  gscoped_ptr<DeltaFileWriter> cur_redo_writer_;
-  gscoped_ptr<DeltaStats> cur_redo_delta_stats;
+  std::unique_ptr<DeltaFileWriter> cur_redo_writer_;
+  std::unique_ptr<DeltaStats> cur_redo_delta_stats_;
   BlockId cur_undo_ds_block_id_;
   BlockId cur_redo_ds_block_id_;
 
@@ -363,7 +362,7 @@ class DiskRowSet : public RowSet {
   virtual Status NewCompactionInput(const Schema* projection,
                                     const MvccSnapshot &snap,
                                     const fs::IOContext* io_context,
-                                    gscoped_ptr<CompactionInput>* out) const override;
+                                    std::unique_ptr<CompactionInput>* out) const override;
 
   // Gets the number of rows in this rowset, checking 'num_rows_' first. If not
   // yet set, consults the base data and stores the result in 'num_rows_'.
@@ -463,7 +462,7 @@ class DiskRowSet : public RowSet {
   Status NewMajorDeltaCompaction(const std::vector<ColumnId>& col_ids,
                                  HistoryGcOpts history_gc_opts,
                                  const fs::IOContext* io_context,
-                                 gscoped_ptr<MajorDeltaCompaction>* out) const;
+                                 std::unique_ptr<MajorDeltaCompaction>* out) const;
 
   // Major compacts all the delta files for the specified columns.
   Status MajorCompactDeltaStoresWithColumnIds(const std::vector<ColumnId>& col_ids,
@@ -481,7 +480,7 @@ class DiskRowSet : public RowSet {
   // Base data for this rowset.
   mutable rw_spinlock component_lock_;
   std::shared_ptr<CFileSet> base_data_;
-  gscoped_ptr<DeltaTracker> delta_tracker_;
+  std::unique_ptr<DeltaTracker> delta_tracker_;
 
   // Number of rows in the rowset. This may be unset (-1) if the rows in the
   // underlying cfile set have not been counted yet.
diff --git a/src/kudu/tablet/local_tablet_writer.h b/src/kudu/tablet/local_tablet_writer.h
index dc5e938..33fde5f 100644
--- a/src/kudu/tablet/local_tablet_writer.h
+++ b/src/kudu/tablet/local_tablet_writer.h
@@ -14,9 +14,9 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef KUDU_TABLET_LOCAL_TABLET_WRITER_H
-#define KUDU_TABLET_LOCAL_TABLET_WRITER_H
+#pragma once
 
+#include <memory>
 #include <vector>
 
 #include "kudu/common/partial_row.h"
@@ -144,7 +144,7 @@ class LocalTabletWriter {
 
   TxResultPB result_;
   tserver::WriteRequestPB req_;
-  gscoped_ptr<WriteTransactionState> tx_state_;
+  std::unique_ptr<WriteTransactionState> tx_state_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalTabletWriter);
 };
@@ -152,4 +152,3 @@ class LocalTabletWriter {
 
 } // namespace tablet
 } // namespace kudu
-#endif /* KUDU_TABLET_LOCAL_TABLET_WRITER_H */
diff --git a/src/kudu/tablet/lock_manager.cc b/src/kudu/tablet/lock_manager.cc
index e914994..ac6ecf6 100644
--- a/src/kudu/tablet/lock_manager.cc
+++ b/src/kudu/tablet/lock_manager.cc
@@ -18,6 +18,7 @@
 #include "kudu/tablet/lock_manager.h"
 
 #include <cstdint>
+#include <memory>
 #include <mutex>
 #include <ostream>
 #include <string>
@@ -26,7 +27,6 @@
 
 #include "kudu/gutil/atomicops.h"
 #include "kudu/gutil/dynamic_annotations.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/hash/city.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/walltime.h"
@@ -38,6 +38,8 @@
 #include "kudu/util/trace.h"
 
 using base::subtle::NoBarrier_Load;
+using std::string;
+using std::unique_ptr;
 
 namespace kudu {
 namespace tablet {
@@ -64,7 +66,7 @@ class LockEntry {
     return key_hash_ == hash && key_ == key;
   }
 
-  std::string ToString() const {
+  string ToString() const {
     return KUDU_REDACT(key_.ToDebugString());
   }
 
@@ -165,7 +167,7 @@ class LockTable {
   // number of buckets in the table
   uint64_t size_;
   // table buckets
-  gscoped_array<Bucket> buckets_;
+  unique_ptr<Bucket[]> buckets_;
   // number of items in the table
   base::subtle::Atomic64 item_count_;
 };
@@ -244,7 +246,7 @@ void LockTable::Resize() {
     return;
 
   // Allocate a new bucket list
-  gscoped_array<Bucket> new_buckets(new Bucket[new_size]);
+  unique_ptr<Bucket[]> new_buckets(new Bucket[new_size]);
   size_t new_mask = new_size - 1;
 
   // Copy entries
diff --git a/src/kudu/tablet/memrowset.cc b/src/kudu/tablet/memrowset.cc
index 49d04b7..8a1db29 100644
--- a/src/kudu/tablet/memrowset.cc
+++ b/src/kudu/tablet/memrowset.cc
@@ -19,7 +19,6 @@
 
 #include <memory>
 #include <string>
-#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -310,7 +309,7 @@ Status MemRowSet::NewRowIterator(const RowIteratorOptions& opts,
 Status MemRowSet::NewCompactionInput(const Schema* projection,
                                      const MvccSnapshot& snap,
                                      const IOContext* /*io_context*/,
-                                     gscoped_ptr<CompactionInput>* out) const  {
+                                     unique_ptr<CompactionInput>* out) const  {
   out->reset(CompactionInput::Create(*this, projection, snap));
   return Status::OK();
 }
@@ -342,7 +341,7 @@ typedef MemRowSet::Iterator::MRSRowProjector MRSRowProjector;
 template<class ActualProjector>
 class MRSRowProjectorImpl : public MRSRowProjector {
  public:
-  explicit MRSRowProjectorImpl(gscoped_ptr<ActualProjector> actual)
+  explicit MRSRowProjectorImpl(unique_ptr<ActualProjector> actual)
     : actual_(std::move(actual)) {}
 
   Status Init() override { return actual_->Init(); }
@@ -362,26 +361,26 @@ class MRSRowProjectorImpl : public MRSRowProjector {
   }
 
  private:
-  gscoped_ptr<ActualProjector> actual_;
+  unique_ptr<ActualProjector> actual_;
 };
 
 // If codegen is enabled, then generates a codegen::RowProjector;
 // otherwise makes a regular one.
-gscoped_ptr<MRSRowProjector> GenerateAppropriateProjector(
+unique_ptr<MRSRowProjector> GenerateAppropriateProjector(
   const Schema* base, const Schema* projection) {
   // Attempt code-generated implementation
   if (FLAGS_mrs_use_codegen) {
-    gscoped_ptr<codegen::RowProjector> actual;
+    unique_ptr<codegen::RowProjector> actual;
     if (codegen::CompilationManager::GetSingleton()->RequestRowProjector(
           base, projection, &actual)) {
-      return gscoped_ptr<MRSRowProjector>(
+      return unique_ptr<MRSRowProjector>(
         new MRSRowProjectorImpl<codegen::RowProjector>(std::move(actual)));
     }
   }
 
   // Proceed with default implementation
-  gscoped_ptr<RowProjector> actual(new RowProjector(base, projection));
-  return gscoped_ptr<MRSRowProjector>(
+  unique_ptr<RowProjector> actual(new RowProjector(base, projection));
+  return unique_ptr<MRSRowProjector>(
     new MRSRowProjectorImpl<RowProjector>(std::move(actual)));
 }
 
diff --git a/src/kudu/tablet/memrowset.h b/src/kudu/tablet/memrowset.h
index f632cc7..ecd8e03 100644
--- a/src/kudu/tablet/memrowset.h
+++ b/src/kudu/tablet/memrowset.h
@@ -36,7 +36,6 @@
 #include "kudu/common/timestamp.h"
 #include "kudu/consensus/log_anchor_registry.h"
 #include "kudu/gutil/atomicops.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/tablet/concurrent_btree.h"
 #include "kudu/tablet/rowset.h"
@@ -331,7 +330,7 @@ class MemRowSet : public RowSet,
   virtual Status NewCompactionInput(const Schema* projection,
                                     const MvccSnapshot& snap,
                                     const fs::IOContext* io_context,
-                                    gscoped_ptr<CompactionInput>* out) const override;
+                                    std::unique_ptr<CompactionInput>* out) const override;
 
   // Return the Schema for the rows in this memrowset.
    const Schema &schema() const {
@@ -592,7 +591,7 @@ class MemRowSet::Iterator : public RowwiseIterator {
                                       ApplyStatus* apply_status);
 
   const std::shared_ptr<const MemRowSet> memrowset_;
-  gscoped_ptr<MemRowSet::MSBTIter> iter_;
+  std::unique_ptr<MemRowSet::MSBTIter> iter_;
 
   const RowIteratorOptions opts_;
 
@@ -600,7 +599,7 @@ class MemRowSet::Iterator : public RowwiseIterator {
   // Relies on the MRSRowProjector interface to abstract from the two
   // different implementations of the RowProjector, which may change
   // at runtime (using vs. not using code generation).
-  const gscoped_ptr<MRSRowProjector> projector_;
+  const std::unique_ptr<MRSRowProjector> projector_;
   DeltaProjector delta_projector_;
 
   // The index of the first IS_DELETED virtual column in the projection schema,
diff --git a/src/kudu/tablet/mock-rowsets.h b/src/kudu/tablet/mock-rowsets.h
index 719b748..b86153f 100644
--- a/src/kudu/tablet/mock-rowsets.h
+++ b/src/kudu/tablet/mock-rowsets.h
@@ -14,8 +14,7 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef KUDU_TABLET_MOCK_ROWSETS_H
-#define KUDU_TABLET_MOCK_ROWSETS_H
+#pragma once
 
 #include <memory>
 #include <mutex>
@@ -62,7 +61,7 @@ class MockRowSet : public RowSet {
   virtual Status NewCompactionInput(const Schema* /*projection*/,
                                     const MvccSnapshot& /*snap*/,
                                     const fs::IOContext* /*io_context*/,
-                                    gscoped_ptr<CompactionInput>* /*out*/) const OVERRIDE {
+                                    std::unique_ptr<CompactionInput>* /*out*/) const OVERRIDE {
     LOG(FATAL) << "Unimplemented";
     return Status::OK();
   }
@@ -237,4 +236,3 @@ class MockMemRowSet : public MockRowSet {
 
 } // namespace tablet
 } // namespace kudu
-#endif /* KUDU_TABLET_MOCK_ROWSETS_H */
diff --git a/src/kudu/tablet/multi_column_writer.cc b/src/kudu/tablet/multi_column_writer.cc
index 6e39b0f..667aa3f 100644
--- a/src/kudu/tablet/multi_column_writer.cc
+++ b/src/kudu/tablet/multi_column_writer.cc
@@ -30,7 +30,6 @@
 #include "kudu/fs/block_id.h"
 #include "kudu/fs/block_manager.h"
 #include "kudu/fs/fs_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/substitute.h"
 
@@ -85,7 +84,7 @@ Status MultiColumnWriter::Open() {
     BlockId block_id(block->id());
 
     // Create the CFile writer itself.
-    gscoped_ptr<CFileWriter> writer(new CFileWriter(
+    unique_ptr<CFileWriter> writer(new CFileWriter(
         std::move(opts),
         col.type_info(),
         col.is_nullable(),
diff --git a/src/kudu/tablet/row_op.cc b/src/kudu/tablet/row_op.cc
index efe28e0..989ebfa 100644
--- a/src/kudu/tablet/row_op.cc
+++ b/src/kudu/tablet/row_op.cc
@@ -17,7 +17,7 @@
 
 #include "kudu/tablet/row_op.h"
 
-#include <type_traits>
+#include <memory>
 #include <utility>
 
 #include <glog/logging.h>
@@ -28,6 +28,7 @@
 #include "kudu/util/status.h"
 
 using kudu::pb_util::SecureDebugString;
+using std::unique_ptr;
 
 namespace kudu {
 
@@ -58,7 +59,7 @@ void RowOp::SetErrorIgnored() {
   error_ignored = true;
 }
 
-void RowOp::SetMutateSucceeded(gscoped_ptr<OperationResultPB> result) {
+void RowOp::SetMutateSucceeded(unique_ptr<OperationResultPB> result) {
   DCHECK(!this->result) << SecureDebugString(*result);
   this->result = std::move(result);
 }
diff --git a/src/kudu/tablet/row_op.h b/src/kudu/tablet/row_op.h
index ade5ef9..c2bbf16 100644
--- a/src/kudu/tablet/row_op.h
+++ b/src/kudu/tablet/row_op.h
@@ -14,13 +14,12 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef KUDU_TABLET_ROW_OP_H
-#define KUDU_TABLET_ROW_OP_H
+#pragma once
 
+#include <memory>
 #include <string>
 
 #include "kudu/common/row_operations.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/tablet/lock_manager.h"
 #include "kudu/tablet/rowset.h"
 #include "kudu/tablet/tablet.pb.h"
@@ -43,7 +42,7 @@ struct RowOp {
   void SetFailed(const Status& s);
   void SetInsertSucceeded(int mrs_id);
   void SetErrorIgnored();
-  void SetMutateSucceeded(gscoped_ptr<OperationResultPB> result);
+  void SetMutateSucceeded(std::unique_ptr<OperationResultPB> result);
   // Sets the result of a skipped operation on bootstrap.
   // TODO(dralves) Currently this performs a copy. Might be avoided with some refactoring.
   // see TODO(dralves) in TabletBoostrap::ApplyOperations().
@@ -78,7 +77,7 @@ struct RowOp {
   // The key probe structure contains the row key in both key-encoded and
   // ContiguousRow formats, bloom probe structure, etc. This is set during
   // the "prepare" phase.
-  gscoped_ptr<RowSetKeyProbe> key_probe;
+  std::unique_ptr<RowSetKeyProbe> key_probe;
 
   // The row lock which has been acquired for this row. Set during the "prepare"
   // phase.
@@ -102,10 +101,9 @@ struct RowOp {
   RowSet* present_in_rowset = nullptr;
 
   // The result of the operation.
-  gscoped_ptr<OperationResultPB> result;
+  std::unique_ptr<OperationResultPB> result;
 };
 
 
 } // namespace tablet
 } // namespace kudu
-#endif /* KUDU_TABLET_ROW_OP_H */
diff --git a/src/kudu/tablet/rowset.cc b/src/kudu/tablet/rowset.cc
index 3566fb1..2247e2d 100644
--- a/src/kudu/tablet/rowset.cc
+++ b/src/kudu/tablet/rowset.cc
@@ -138,7 +138,7 @@ Status DuplicatingRowSet::NewRowIterator(const RowIteratorOptions& opts,
 Status DuplicatingRowSet::NewCompactionInput(const Schema* /*projection*/,
                                              const MvccSnapshot& /*snap*/,
                                              const IOContext* /*io_context*/,
-                                             gscoped_ptr<CompactionInput>* /*out*/) const  {
+                                             unique_ptr<CompactionInput>* /*out*/) const  {
   LOG(FATAL) << "duplicating rowsets do not act as compaction input";
   return Status::OK();
 }
diff --git a/src/kudu/tablet/rowset.h b/src/kudu/tablet/rowset.h
index 9e96e2c..524572a 100644
--- a/src/kudu/tablet/rowset.h
+++ b/src/kudu/tablet/rowset.h
@@ -32,7 +32,6 @@
 #include "kudu/common/row.h"
 #include "kudu/common/rowid.h"
 #include "kudu/common/timestamp.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/port.h"
 #include "kudu/tablet/mvcc.h"
@@ -157,7 +156,7 @@ class RowSet {
   virtual Status NewCompactionInput(const Schema* projection,
                                     const MvccSnapshot &snap,
                                     const fs::IOContext* io_context,
-                                    gscoped_ptr<CompactionInput>* out) const = 0;
+                                    std::unique_ptr<CompactionInput>* out) const = 0;
 
   // Count the number of rows in this rowset.
   virtual Status CountRows(const fs::IOContext* io_context, rowid_t *count) const = 0;
@@ -404,7 +403,7 @@ class DuplicatingRowSet : public RowSet {
   virtual Status NewCompactionInput(const Schema* projection,
                                     const MvccSnapshot &snap,
                                     const fs::IOContext* io_context,
-                                    gscoped_ptr<CompactionInput>* out) const OVERRIDE;
+                                    std::unique_ptr<CompactionInput>* out) const OVERRIDE;
 
   Status CountRows(const fs::IOContext* io_context, rowid_t *count) const OVERRIDE;
 
diff --git a/src/kudu/tablet/rowset_tree.cc b/src/kudu/tablet/rowset_tree.cc
index dc3a25b..0ff9dea 100644
--- a/src/kudu/tablet/rowset_tree.cc
+++ b/src/kudu/tablet/rowset_tree.cc
@@ -34,9 +34,10 @@
 #include "kudu/util/interval_tree-inl.h"
 #include "kudu/util/slice.h"
 
-using std::vector;
 using std::shared_ptr;
 using std::string;
+using std::unique_ptr;
+using std::vector;
 
 namespace kudu {
 namespace tablet {
@@ -137,9 +138,10 @@ Status RowSetTree::Reset(const RowSetVector &rowsets) {
   // Iterate over each of the provided RowSets, fetching their
   // bounds and adding them to the local vectors.
   for (const shared_ptr<RowSet> &rs : rowsets) {
-    gscoped_ptr<RowSetWithBounds> rsit(new RowSetWithBounds());
+    unique_ptr<RowSetWithBounds> rsit(new RowSetWithBounds());
     rsit->rowset = rs.get();
-    string min_key, max_key;
+    string min_key;
+    string max_key;
     Status s = rs->GetBounds(&min_key, &max_key);
     if (s.IsNotSupported()) {
       // This rowset is a MemRowSet, for which the bounds change as more
diff --git a/src/kudu/tablet/rowset_tree.h b/src/kudu/tablet/rowset_tree.h
index 7c566de..1245aee 100644
--- a/src/kudu/tablet/rowset_tree.h
+++ b/src/kudu/tablet/rowset_tree.h
@@ -14,17 +14,16 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef KUDU_TABLET_ROWSET_MANAGER_H
-#define KUDU_TABLET_ROWSET_MANAGER_H
+#pragma once
 
 #include <cstdint>
 #include <functional>
+#include <memory>
 #include <unordered_map>
 #include <vector>
 
 #include <boost/optional/optional.hpp>
 
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/tablet/rowset.h"
 #include "kudu/util/slice.h"
@@ -112,7 +111,7 @@ class RowSetTree {
  private:
   // Interval tree of the rowsets. Used to efficiently find rowsets which might contain
   // a probe row.
-  gscoped_ptr<IntervalTree<RowSetIntervalTraits> > tree_;
+  std::unique_ptr<IntervalTree<RowSetIntervalTraits>> tree_;
 
   // Ordered map of all the interval endpoints, holding the implicit contiguous
   // intervals
@@ -142,4 +141,3 @@ class RowSetTree {
 
 } // namespace tablet
 } // namespace kudu
-#endif
diff --git a/src/kudu/tablet/tablet-harness.h b/src/kudu/tablet/tablet-harness.h
index c3197e9..346155d 100644
--- a/src/kudu/tablet/tablet-harness.h
+++ b/src/kudu/tablet/tablet-harness.h
@@ -158,7 +158,7 @@ class TabletHarness {
 
   std::unique_ptr<clock::Clock> clock_;
   Schema schema_;
-  gscoped_ptr<FsManager> fs_manager_;
+  std::unique_ptr<FsManager> fs_manager_;
   std::shared_ptr<Tablet> tablet_;
 };
 
diff --git a/src/kudu/tablet/tablet-test-util.h b/src/kudu/tablet/tablet-test-util.h
index 5e0bcc9..937221b 100644
--- a/src/kudu/tablet/tablet-test-util.h
+++ b/src/kudu/tablet/tablet-test-util.h
@@ -52,7 +52,6 @@
 #include "kudu/fs/block_id.h"
 #include "kudu/fs/block_manager.h"
 #include "kudu/fs/fs_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/strings/join.h"
@@ -173,7 +172,7 @@ class KuduTabletTest : public KuduTest {
   const Schema client_schema_;
   const TabletHarness::Options::ClockType clock_type_;
 
-  gscoped_ptr<TabletHarness> harness_;
+  std::unique_ptr<TabletHarness> harness_;
 };
 
 class KuduRowSetTest : public KuduTabletTest {
diff --git a/src/kudu/tablet/tablet.cc b/src/kudu/tablet/tablet.cc
index d2a158c..32541cf 100644
--- a/src/kudu/tablet/tablet.cc
+++ b/src/kudu/tablet/tablet.cc
@@ -22,7 +22,6 @@
 #include <memory>
 #include <mutex>
 #include <ostream>
-#include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
@@ -531,7 +530,7 @@ void Tablet::AssignTimestampAndStartTransactionForTests(WriteTransactionState* t
 }
 
 void Tablet::StartTransaction(WriteTransactionState* tx_state) {
-  gscoped_ptr<ScopedTransaction> mvcc_tx;
+  unique_ptr<ScopedTransaction> mvcc_tx;
   DCHECK(tx_state->has_timestamp());
   mvcc_tx.reset(new ScopedTransaction(&mvcc_, tx_state->timestamp()));
   tx_state->SetMvccTx(std::move(mvcc_tx));
@@ -690,7 +689,7 @@ Status Tablet::ApplyUpsertAsUpdate(const IOContext* io_context,
   // were unset (eg because the table only _has_ primary keys, or because
   // the rest are intended to be set to their defaults), we need to
   // avoid doing anything.
-  gscoped_ptr<OperationResultPB> result(new OperationResultPB());
+  unique_ptr<OperationResultPB> result(new OperationResultPB());
   if (enc.is_empty()) {
     upsert->SetMutateSucceeded(std::move(result));
     return Status::OK();
@@ -764,7 +763,7 @@ Status Tablet::MutateRowUnlocked(const IOContext* io_context,
   DCHECK(mutate->checked_present);
   DCHECK(mutate->valid);
 
-  gscoped_ptr<OperationResultPB> result(new OperationResultPB());
+  unique_ptr<OperationResultPB> result(new OperationResultPB());
   const TabletComponents* comps = DCHECK_NOTNULL(tx_state->tablet_components());
   Timestamp ts = tx_state->timestamp();
 
@@ -1460,19 +1459,19 @@ void Tablet::RegisterMaintenanceOps(MaintenanceManager* maint_mgr) {
   }
 
   vector<MaintenanceOp*> maintenance_ops;
-  gscoped_ptr<MaintenanceOp> rs_compact_op(new CompactRowSetsOp(this));
+  unique_ptr<MaintenanceOp> rs_compact_op(new CompactRowSetsOp(this));
   maint_mgr->RegisterOp(rs_compact_op.get());
   maintenance_ops.push_back(rs_compact_op.release());
 
-  gscoped_ptr<MaintenanceOp> minor_delta_compact_op(new MinorDeltaCompactionOp(this));
+  unique_ptr<MaintenanceOp> minor_delta_compact_op(new MinorDeltaCompactionOp(this));
   maint_mgr->RegisterOp(minor_delta_compact_op.get());
   maintenance_ops.push_back(minor_delta_compact_op.release());
 
-  gscoped_ptr<MaintenanceOp> major_delta_compact_op(new MajorDeltaCompactionOp(this));
+  unique_ptr<MaintenanceOp> major_delta_compact_op(new MajorDeltaCompactionOp(this));
   maint_mgr->RegisterOp(major_delta_compact_op.get());
   maintenance_ops.push_back(major_delta_compact_op.release());
 
-  gscoped_ptr<MaintenanceOp> undo_delta_block_gc_op(new UndoDeltaBlockGCOp(this));
+  unique_ptr<MaintenanceOp> undo_delta_block_gc_op(new UndoDeltaBlockGCOp(this));
   maint_mgr->RegisterOp(undo_delta_block_gc_op.get());
   maintenance_ops.push_back(undo_delta_block_gc_op.release());
 
diff --git a/src/kudu/tablet/tablet.h b/src/kudu/tablet/tablet.h
index 9c6d810..6950cc0 100644
--- a/src/kudu/tablet/tablet.h
+++ b/src/kudu/tablet/tablet.h
@@ -32,7 +32,6 @@
 #include "kudu/common/iterator.h"
 #include "kudu/common/schema.h"
 #include "kudu/fs/io_context.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/port.h"
@@ -722,7 +721,7 @@ class Tablet {
   TabletMemTrackers mem_trackers_;
 
   scoped_refptr<MetricEntity> metric_entity_;
-  gscoped_ptr<TabletMetrics> metrics_;
+  std::unique_ptr<TabletMetrics> metrics_;
 
   std::unique_ptr<Throttler> throttler_;
 
@@ -734,7 +733,7 @@ class Tablet {
   MvccManager mvcc_;
   LockManager lock_manager_;
 
-  gscoped_ptr<CompactionPolicy> compaction_policy_;
+  std::unique_ptr<CompactionPolicy> compaction_policy_;
 
   // Lock protecting the selection of rowsets for compaction.
   // Only one thread may run the compaction selection algorithm at a time
diff --git a/src/kudu/tablet/tablet_bootstrap-test.cc b/src/kudu/tablet/tablet_bootstrap-test.cc
index 46229f7..c3fd891 100644
--- a/src/kudu/tablet/tablet_bootstrap-test.cc
+++ b/src/kudu/tablet/tablet_bootstrap-test.cc
@@ -22,7 +22,6 @@
 #include <memory>
 #include <ostream>
 #include <string>
-#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -57,7 +56,6 @@
 #include "kudu/consensus/ref_counted_replicate.h"
 #include "kudu/fs/data_dirs.h"
 #include "kudu/fs/fs_manager.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/rpc/result_tracker.h"
@@ -528,7 +526,7 @@ TEST_F(BootstrapTest, TestOutOfOrderCommits) {
   ASSERT_OK(AppendReplicateBatch(replicate));
 
   // Now commit the mutate before the insert (in the log).
-  gscoped_ptr<consensus::CommitMsg> mutate_commit(new consensus::CommitMsg);
+  unique_ptr<consensus::CommitMsg> mutate_commit(new consensus::CommitMsg);
   mutate_commit->set_op_type(consensus::WRITE_OP);
   mutate_commit->mutable_commited_op_id()->CopyFrom(mutate_opid);
   TxResultPB* result = mutate_commit->mutable_result();
@@ -538,7 +536,7 @@ TEST_F(BootstrapTest, TestOutOfOrderCommits) {
 
   ASSERT_OK(AppendCommit(std::move(mutate_commit)));
 
-  gscoped_ptr<consensus::CommitMsg> insert_commit(new consensus::CommitMsg);
+  unique_ptr<consensus::CommitMsg> insert_commit(new consensus::CommitMsg);
   insert_commit->set_op_type(consensus::WRITE_OP);
   insert_commit->mutable_commited_op_id()->CopyFrom(insert_opid);
   result = insert_commit->mutable_result();
@@ -592,7 +590,7 @@ TEST_F(BootstrapTest, TestMissingCommitMessage) {
   ASSERT_OK(AppendReplicateBatch(replicate));
 
   // Now commit the mutate before the insert (in the log).
-  gscoped_ptr<consensus::CommitMsg> mutate_commit(new consensus::CommitMsg);
+  unique_ptr<consensus::CommitMsg> mutate_commit(new consensus::CommitMsg);
   mutate_commit->set_op_type(consensus::WRITE_OP);
   mutate_commit->mutable_commited_op_id()->CopyFrom(mutate_opid);
   TxResultPB* result = mutate_commit->mutable_result();
@@ -644,14 +642,14 @@ TEST_F(BootstrapTest, TestConsensusOnlyOperationOutOfOrderTimestamp) {
 
   // Now commit in OpId order.
   // NO_OP...
-  gscoped_ptr<consensus::CommitMsg> mutate_commit(new consensus::CommitMsg);
+  unique_ptr<consensus::CommitMsg> mutate_commit(new consensus::CommitMsg);
   mutate_commit->set_op_type(consensus::NO_OP);
   *mutate_commit->mutable_commited_op_id() = noop_replicate->get()->id();
 
   ASSERT_OK(AppendCommit(std::move(mutate_commit)));
 
   // ...and WRITE_OP...
-  mutate_commit = gscoped_ptr<consensus::CommitMsg>(new consensus::CommitMsg);
+  mutate_commit = unique_ptr<consensus::CommitMsg>(new consensus::CommitMsg);
   mutate_commit->set_op_type(consensus::WRITE_OP);
   *mutate_commit->mutable_commited_op_id() = write_replicate->get()->id();
   TxResultPB* result = mutate_commit->mutable_result();
@@ -719,13 +717,13 @@ TEST_F(BootstrapTest, TestKudu2509) {
   ASSERT_OK(AppendReplicateBatch(replicate));
 
   // Now commit the mutate before the insert (in the log).
-  gscoped_ptr<consensus::CommitMsg> mutate_commit(new consensus::CommitMsg);
+  unique_ptr<consensus::CommitMsg> mutate_commit(new consensus::CommitMsg);
   mutate_commit->set_op_type(consensus::WRITE_OP);
   mutate_commit->mutable_commited_op_id()->CopyFrom(mutate_opid);
   mutate_commit->mutable_result()->add_ops()->add_mutated_stores()->set_mrs_id(1);
   ASSERT_OK(AppendCommit(std::move(mutate_commit)));
 
-  gscoped_ptr<consensus::CommitMsg> insert_commit(new consensus::CommitMsg);
+  unique_ptr<consensus::CommitMsg> insert_commit(new consensus::CommitMsg);
   insert_commit->set_op_type(consensus::WRITE_OP);
   insert_commit->mutable_commited_op_id()->CopyFrom(insert_opid);
   insert_commit->mutable_result()->add_ops()->add_mutated_stores()->set_mrs_id(1);
diff --git a/src/kudu/tablet/tablet_bootstrap.cc b/src/kudu/tablet/tablet_bootstrap.cc
index 85f5c5c..b4d980f 100644
--- a/src/kudu/tablet/tablet_bootstrap.cc
+++ b/src/kudu/tablet/tablet_bootstrap.cc
@@ -55,7 +55,6 @@
 #include "kudu/fs/fs_manager.h"
 #include "kudu/fs/io_context.h"
 #include "kudu/gutil/bind.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/port.h"
diff --git a/src/kudu/tablet/tablet_metadata-test.cc b/src/kudu/tablet/tablet_metadata-test.cc
index 1e69ce7..7ef0433 100644
--- a/src/kudu/tablet/tablet_metadata-test.cc
+++ b/src/kudu/tablet/tablet_metadata-test.cc
@@ -33,7 +33,6 @@
 #include "kudu/common/schema.h"
 #include "kudu/common/wire_protocol-test-util.h"
 #include "kudu/fs/block_id.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/tablet/local_tablet_writer.h"
@@ -70,14 +69,14 @@ class TestTabletMetadata : public KuduTabletTest {
   }
 
   void BuildPartialRow(int key, int intval, const char* strval,
-                       gscoped_ptr<KuduPartialRow>* row);
+                       unique_ptr<KuduPartialRow>* row);
 
  protected:
-  gscoped_ptr<LocalTabletWriter> writer_;
+  unique_ptr<LocalTabletWriter> writer_;
 };
 
 void TestTabletMetadata::BuildPartialRow(int key, int intval, const char* strval,
-                                         gscoped_ptr<KuduPartialRow>* row) {
+                                         unique_ptr<KuduPartialRow>* row) {
   row->reset(new KuduPartialRow(&client_schema_));
   CHECK_OK((*row)->SetInt32(0, key));
   CHECK_OK((*row)->SetInt32(1, intval));
@@ -89,7 +88,7 @@ TEST_F(TestTabletMetadata, TestLoadFromSuperBlock) {
   TabletMetadata* meta = harness_->tablet()->metadata();
 
   // Write some data to the tablet and flush.
-  gscoped_ptr<KuduPartialRow> row;
+  unique_ptr<KuduPartialRow> row;
   BuildPartialRow(0, 0, "foo", &row);
   ASSERT_OK(writer_->Insert(*row));
   ASSERT_OK(harness_->tablet()->Flush());
@@ -168,7 +167,7 @@ TEST_F(TestTabletMetadata, TestOnDiskSize) {
   ASSERT_GT(initial_size, 0);
 
   // Write some data to the tablet and flush.
-  gscoped_ptr<KuduPartialRow> row;
+  unique_ptr<KuduPartialRow> row;
   BuildPartialRow(0, 0, "foo", &row);
   writer_->Insert(*row);
   ASSERT_OK(harness_->tablet()->Flush());
diff --git a/src/kudu/tablet/tablet_metadata.cc b/src/kudu/tablet/tablet_metadata.cc
index 129da86..754f53c 100644
--- a/src/kudu/tablet/tablet_metadata.cc
+++ b/src/kudu/tablet/tablet_metadata.cc
@@ -21,7 +21,6 @@
 #include <mutex>
 #include <ostream>
 #include <string>
-#include <type_traits>
 
 #include <boost/optional/optional.hpp>
 #include <gflags/gflags.h>
@@ -368,7 +367,7 @@ Status TabletMetadata::LoadFromSuperBlock(const TabletSuperBlockPB& superblock)
     table_name_ = superblock.table_name();
 
     uint32_t schema_version = superblock.schema_version();
-    gscoped_ptr<Schema> schema(new Schema());
+    unique_ptr<Schema> schema(new Schema());
     RETURN_NOT_OK_PREPEND(SchemaFromPB(superblock.schema(), schema.get()),
                           "Failed to parse Schema from superblock " +
                           SecureShortDebugString(superblock));
@@ -757,12 +756,12 @@ RowSetMetadata *TabletMetadata::GetRowSetForTests(int64_t id) {
 }
 
 void TabletMetadata::SetSchema(const Schema& schema, uint32_t version) {
-  gscoped_ptr<Schema> new_schema(new Schema(schema));
+  unique_ptr<Schema> new_schema(new Schema(schema));
   std::lock_guard<LockType> l(data_lock_);
   SetSchemaUnlocked(std::move(new_schema), version);
 }
 
-void TabletMetadata::SetSchemaUnlocked(gscoped_ptr<Schema> new_schema, uint32_t version) {
+void TabletMetadata::SetSchemaUnlocked(unique_ptr<Schema> new_schema, uint32_t version) {
   DCHECK(new_schema->has_column_ids());
 
   Schema* old_schema = schema_;
diff --git a/src/kudu/tablet/tablet_metadata.h b/src/kudu/tablet/tablet_metadata.h
index fae2a3c..384a9ca 100644
--- a/src/kudu/tablet/tablet_metadata.h
+++ b/src/kudu/tablet/tablet_metadata.h
@@ -30,7 +30,6 @@
 #include "kudu/fs/block_id.h"
 #include "kudu/gutil/atomicops.h"
 #include "kudu/gutil/callback.h"  // IWYU pragma: keep
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/tablet/metadata.pb.h"
@@ -311,7 +310,7 @@ class TabletMetadata : public RefCountedThreadSafe<TabletMetadata> {
   // Constructor for loading an existing tablet.
   TabletMetadata(FsManager* fs_manager, std::string tablet_id);
 
-  void SetSchemaUnlocked(gscoped_ptr<Schema> schema, uint32_t version);
+  void SetSchemaUnlocked(std::unique_ptr<Schema> schema, uint32_t version);
 
   Status LoadFromDisk();
 
@@ -370,7 +369,7 @@ class TabletMetadata : public RefCountedThreadSafe<TabletMetadata> {
   int64_t last_durable_mrs_id_;
 
   // The current schema version. This is owned by this class.
-  // We don't use gscoped_ptr so that we can do an atomic swap.
+  // We don't use unique_ptr so that we can do an atomic swap.
   Schema* schema_;
   uint32_t schema_version_;
   std::string table_name_;
diff --git a/src/kudu/tablet/tablet_random_access-test.cc b/src/kudu/tablet/tablet_random_access-test.cc
index 3452742..b02af28 100644
--- a/src/kudu/tablet/tablet_random_access-test.cc
+++ b/src/kudu/tablet/tablet_random_access-test.cc
@@ -37,7 +37,6 @@
 #include "kudu/common/scan_spec.h"
 #include "kudu/common/schema.h"
 #include "kudu/common/wire_protocol.pb.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/tablet/key_value_test_schema.h"
@@ -227,7 +226,7 @@ class TestRandomAccess : public KuduTabletTest {
                                         const optional<ExpectedKeyValueRow>& old_row,
                                         vector<LocalTabletWriter::Op>* ops) {
 
-    gscoped_ptr<KuduPartialRow> row(new KuduPartialRow(&client_schema_));
+    unique_ptr<KuduPartialRow> row(new KuduPartialRow(&client_schema_));
     CHECK_OK(row->SetInt32(0, key));
     optional<ExpectedKeyValueRow> ret = ExpectedKeyValueRow();
     ret->key = key;
@@ -275,7 +274,7 @@ class TestRandomAccess : public KuduTabletTest {
   // Adds a delete of the given row to 'ops', returning an empty string (indicating that
   // the row no longer exists).
   optional<ExpectedKeyValueRow> DeleteRow(int key, vector<LocalTabletWriter::Op>* ops) {
-    gscoped_ptr<KuduPartialRow> row(new KuduPartialRow(&client_schema_));
+    unique_ptr<KuduPartialRow> row(new KuduPartialRow(&client_schema_));
     CHECK_OK(row->SetInt32(0, key));
     ops->push_back(LocalTabletWriter::Op(RowOperationsPB::DELETE, row.release()));
     return boost::none;
@@ -330,7 +329,7 @@ class TestRandomAccess : public KuduTabletTest {
   // operations. This stops the compact/flush thread.
   CountDownLatch done_;
 
-  gscoped_ptr<LocalTabletWriter> writer_;
+  unique_ptr<LocalTabletWriter> writer_;
 };
 
 TEST_F(TestRandomAccess, Test) {
diff --git a/src/kudu/tablet/tablet_replica-test.cc b/src/kudu/tablet/tablet_replica-test.cc
index 7cba80d..e6e9c19 100644
--- a/src/kudu/tablet/tablet_replica-test.cc
+++ b/src/kudu/tablet/tablet_replica-test.cc
@@ -49,7 +49,6 @@
 #include "kudu/gutil/bind.h"
 #include "kudu/gutil/bind_helpers.h"
 #include "kudu/gutil/callback.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/rpc/messenger.h"
@@ -343,7 +342,7 @@ class TabletReplicaTest : public KuduTabletTest {
   // Execute insert requests and roll log after each one.
   Status ExecuteInsertsAndRollLogs(int num_inserts) {
     for (int i = 0; i < num_inserts; i++) {
-      gscoped_ptr<WriteRequestPB> req(new WriteRequestPB());
+      unique_ptr<WriteRequestPB> req(new WriteRequestPB());
       RETURN_NOT_OK(GenerateSequentialInsertRequest(GetTestSchema(), req.get()));
       RETURN_NOT_OK(ExecuteWriteAndRollLog(tablet_replica_.get(), *req));
     }
@@ -354,7 +353,7 @@ class TabletReplicaTest : public KuduTabletTest {
   // Execute delete requests and roll log after each one.
   Status ExecuteDeletesAndRollLogs(int num_deletes) {
     for (int i = 0; i < num_deletes; i++) {
-      gscoped_ptr<WriteRequestPB> req(new WriteRequestPB());
+      unique_ptr<WriteRequestPB> req(new WriteRequestPB());
       CHECK_OK(GenerateSequentialDeleteRequest(req.get()));
       CHECK_OK(ExecuteWriteAndRollLog(tablet_replica_.get(), *req));
     }
@@ -413,7 +412,7 @@ class DelayedApplyTransaction : public WriteTransaction {
         apply_continue_(DCHECK_NOTNULL(apply_continue)) {
   }
 
-  virtual Status Apply(gscoped_ptr<CommitMsg>* commit_msg) override {
+  virtual Status Apply(unique_ptr<CommitMsg>* commit_msg) override {
     apply_started_->CountDown();
     LOG(INFO) << "Delaying apply...";
     apply_continue_->Wait();
@@ -579,8 +578,8 @@ TEST_F(TabletReplicaTest, TestActiveTransactionPreventsLogGC) {
   CountDownLatch rpc_latch(1);
   CountDownLatch apply_started(1);
   CountDownLatch apply_continue(1);
-  gscoped_ptr<WriteRequestPB> req(new WriteRequestPB());
-  gscoped_ptr<WriteResponsePB> resp(new WriteResponsePB());
+  unique_ptr<WriteRequestPB> req(new WriteRequestPB());
+  unique_ptr<WriteResponsePB> resp(new WriteResponsePB());
   {
     // Long-running mutation.
     ASSERT_OK(GenerateSequentialDeleteRequest(req.get()));
@@ -592,14 +591,14 @@ TEST_F(TabletReplicaTest, TestActiveTransactionPreventsLogGC) {
     tx_state->set_completion_callback(unique_ptr<TransactionCompletionCallback>(
         new LatchTransactionCompletionCallback<WriteResponsePB>(&rpc_latch, resp.get())));
 
-    gscoped_ptr<DelayedApplyTransaction> transaction(
+    unique_ptr<DelayedApplyTransaction> transaction(
         new DelayedApplyTransaction(&apply_started,
                                     &apply_continue,
                                     std::move(tx_state)));
 
     scoped_refptr<TransactionDriver> driver;
-    ASSERT_OK(tablet_replica_->NewLeaderTransactionDriver(transaction.PassAs<Transaction>(),
-                                                       &driver));
+    ASSERT_OK(tablet_replica_->NewLeaderTransactionDriver(std::move(transaction),
+                                                          &driver));
 
     ASSERT_OK(driver->ExecuteAsync());
     apply_started.Wait();
diff --git a/src/kudu/tablet/tablet_replica.cc b/src/kudu/tablet/tablet_replica.cc
index 41b4324..b02b137 100644
--- a/src/kudu/tablet/tablet_replica.cc
+++ b/src/kudu/tablet/tablet_replica.cc
@@ -23,7 +23,6 @@
 #include <mutex>
 #include <ostream>
 #include <string>
-#include <type_traits>
 #include <vector>
 
 #include <glog/logging.h>
@@ -428,10 +427,10 @@ Status TabletReplica::SubmitWrite(unique_ptr<WriteTransactionState> state) {
   RETURN_NOT_OK(CheckRunning());
 
   state->SetResultTracker(result_tracker_);
-  gscoped_ptr<WriteTransaction> transaction(new WriteTransaction(std::move(state),
+  unique_ptr<WriteTransaction> transaction(new WriteTransaction(std::move(state),
                                                                  consensus::LEADER));
   scoped_refptr<TransactionDriver> driver;
-  RETURN_NOT_OK(NewLeaderTransactionDriver(transaction.PassAs<Transaction>(),
+  RETURN_NOT_OK(NewLeaderTransactionDriver(std::move(transaction),
                                            &driver));
   return driver->ExecuteAsync();
 }
@@ -439,10 +438,10 @@ Status TabletReplica::SubmitWrite(unique_ptr<WriteTransactionState> state) {
 Status TabletReplica::SubmitAlterSchema(unique_ptr<AlterSchemaTransactionState> state) {
   RETURN_NOT_OK(CheckRunning());
 
-  gscoped_ptr<AlterSchemaTransaction> transaction(
+  unique_ptr<AlterSchemaTransaction> transaction(
       new AlterSchemaTransaction(std::move(state), consensus::LEADER));
   scoped_refptr<TransactionDriver> driver;
-  RETURN_NOT_OK(NewLeaderTransactionDriver(transaction.PassAs<Transaction>(), &driver));
+  RETURN_NOT_OK(NewLeaderTransactionDriver(std::move(transaction), &driver));
   return driver->ExecuteAsync();
 }
 
@@ -618,7 +617,7 @@ Status TabletReplica::StartFollowerTransaction(const scoped_refptr<ConsensusRoun
 
   consensus::ReplicateMsg* replicate_msg = round->replicate_msg();
   DCHECK(replicate_msg->has_timestamp());
-  gscoped_ptr<Transaction> transaction;
+  unique_ptr<Transaction> transaction;
   switch (replicate_msg->op_type()) {
     case WRITE_OP:
     {
@@ -703,7 +702,7 @@ void TabletReplica::FinishConsensusOnlyRound(ConsensusRound* round) {
   }
 }
 
-Status TabletReplica::NewLeaderTransactionDriver(gscoped_ptr<Transaction> transaction,
+Status TabletReplica::NewLeaderTransactionDriver(unique_ptr<Transaction> transaction,
                                                  scoped_refptr<TransactionDriver>* driver) {
   scoped_refptr<TransactionDriver> tx_driver = new TransactionDriver(
     &txn_tracker_,
@@ -713,12 +712,12 @@ Status TabletReplica::NewLeaderTransactionDriver(gscoped_ptr<Transaction> transa
     apply_pool_,
     &txn_order_verifier_);
   RETURN_NOT_OK(tx_driver->Init(std::move(transaction), consensus::LEADER));
-  driver->swap(tx_driver);
+  *driver = std::move(tx_driver);
 
   return Status::OK();
 }
 
-Status TabletReplica::NewReplicaTransactionDriver(gscoped_ptr<Transaction> transaction,
+Status TabletReplica::NewReplicaTransactionDriver(unique_ptr<Transaction> transaction,
                                                   scoped_refptr<TransactionDriver>* driver) {
   scoped_refptr<TransactionDriver> tx_driver = new TransactionDriver(
     &txn_tracker_,
@@ -728,7 +727,7 @@ Status TabletReplica::NewReplicaTransactionDriver(gscoped_ptr<Transaction> trans
     apply_pool_,
     &txn_order_verifier_);
   RETURN_NOT_OK(tx_driver->Init(std::move(transaction), consensus::REPLICA));
-  driver->swap(tx_driver);
+  *driver = std::move(tx_driver);
 
   return Status::OK();
 }
@@ -746,15 +745,15 @@ void TabletReplica::RegisterMaintenanceOps(MaintenanceManager* maint_mgr) {
 
   vector<MaintenanceOp*> maintenance_ops;
 
-  gscoped_ptr<MaintenanceOp> mrs_flush_op(new FlushMRSOp(this));
+  unique_ptr<MaintenanceOp> mrs_flush_op(new FlushMRSOp(this));
   maint_mgr->RegisterOp(mrs_flush_op.get());
   maintenance_ops.push_back(mrs_flush_op.release());
 
-  gscoped_ptr<MaintenanceOp> dms_flush_op(new FlushDeltaMemStoresOp(this));
+  unique_ptr<MaintenanceOp> dms_flush_op(new FlushDeltaMemStoresOp(this));
   maint_mgr->RegisterOp(dms_flush_op.get());
   maintenance_ops.push_back(dms_flush_op.release());
 
-  gscoped_ptr<MaintenanceOp> log_gc(new LogGCOp(this));
+  unique_ptr<MaintenanceOp> log_gc(new LogGCOp(this));
   maint_mgr->RegisterOp(log_gc.get());
   maintenance_ops.push_back(log_gc.release());
 
@@ -762,7 +761,7 @@ void TabletReplica::RegisterMaintenanceOps(MaintenanceManager* maint_mgr) {
   {
     std::lock_guard<simple_spinlock> l(lock_);
     DCHECK(maintenance_ops_.empty());
-    maintenance_ops_.swap(maintenance_ops);
+    maintenance_ops_ = std::move(maintenance_ops);
     tablet = tablet_;
   }
   tablet->RegisterMaintenanceOps(maint_mgr);
@@ -780,7 +779,7 @@ void TabletReplica::UnregisterMaintenanceOps() {
   vector<MaintenanceOp*> maintenance_ops;
   {
     std::lock_guard<simple_spinlock> l(lock_);
-    maintenance_ops.swap(maintenance_ops_);
+    maintenance_ops = std::move(maintenance_ops_);
   }
   for (MaintenanceOp* op : maintenance_ops) {
     op->Unregister();
@@ -857,7 +856,7 @@ void TabletReplica::UpdateTabletStats(vector<string>* dirty_tablets) {
     if (consensus::RaftPeerPB_Role_LEADER == role) {
       dirty_tablets->emplace_back(tablet_id());
     }
-    stats_pb_.Swap(&pb);
+    stats_pb_ = std::move(pb);
   }
 }
 
diff --git a/src/kudu/tablet/tablet_replica.h b/src/kudu/tablet/tablet_replica.h
index abc9079..a7e115c 100644
--- a/src/kudu/tablet/tablet_replica.h
+++ b/src/kudu/tablet/tablet_replica.h
@@ -31,7 +31,6 @@
 #include "kudu/consensus/raft_consensus.h"
 #include "kudu/fs/fs_manager.h"
 #include "kudu/gutil/callback.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/tablet/metadata.pb.h"
@@ -259,10 +258,10 @@ class TabletReplica : public RefCountedThreadSafe<TabletReplica>,
   // Convenience method to return the permanent_uuid of this peer.
   std::string permanent_uuid() const { return tablet_->metadata()->fs_manager()->uuid(); }
 
-  Status NewLeaderTransactionDriver(gscoped_ptr<Transaction> transaction,
+  Status NewLeaderTransactionDriver(std::unique_ptr<Transaction> transaction,
                                     scoped_refptr<TransactionDriver>* driver);
 
-  Status NewReplicaTransactionDriver(gscoped_ptr<Transaction> transaction,
+  Status NewReplicaTransactionDriver(std::unique_ptr<Transaction> transaction,
                                      scoped_refptr<TransactionDriver>* driver);
 
   // Tells the tablet's log to garbage collect.
diff --git a/src/kudu/tablet/transactions/alter_schema_transaction.cc b/src/kudu/tablet/transactions/alter_schema_transaction.cc
index a964342..76519c2 100644
--- a/src/kudu/tablet/transactions/alter_schema_transaction.cc
+++ b/src/kudu/tablet/transactions/alter_schema_transaction.cc
@@ -84,7 +84,7 @@ AlterSchemaTransaction::AlterSchemaTransaction(unique_ptr<AlterSchemaTransaction
       state_(std::move(state)) {
 }
 
-void AlterSchemaTransaction::NewReplicateMsg(gscoped_ptr<ReplicateMsg>* replicate_msg) {
+void AlterSchemaTransaction::NewReplicateMsg(unique_ptr<ReplicateMsg>* replicate_msg) {
   replicate_msg->reset(new ReplicateMsg);
   (*replicate_msg)->set_op_type(ALTER_SCHEMA_OP);
   (*replicate_msg)->mutable_alter_schema_request()->CopyFrom(*state()->request());
@@ -94,7 +94,7 @@ Status AlterSchemaTransaction::Prepare() {
   TRACE("PREPARE ALTER-SCHEMA: Starting");
 
   // Decode schema
-  gscoped_ptr<Schema> schema(new Schema);
+  unique_ptr<Schema> schema(new Schema);
   Status s = SchemaFromPB(state_->request()->schema(), schema.get());
   if (!s.ok()) {
     state_->completion_callback()->set_error(s, TabletServerErrorPB::INVALID_SCHEMA);
@@ -118,7 +118,7 @@ Status AlterSchemaTransaction::Start() {
   return Status::OK();
 }
 
-Status AlterSchemaTransaction::Apply(gscoped_ptr<CommitMsg>* commit_msg) {
+Status AlterSchemaTransaction::Apply(unique_ptr<CommitMsg>* commit_msg) {
   TRACE("APPLY ALTER-SCHEMA: Starting");
 
   Tablet* tablet = state_->tablet_replica()->tablet();
diff --git a/src/kudu/tablet/transactions/alter_schema_transaction.h b/src/kudu/tablet/transactions/alter_schema_transaction.h
index 69b9c31..4342ac2 100644
--- a/src/kudu/tablet/transactions/alter_schema_transaction.h
+++ b/src/kudu/tablet/transactions/alter_schema_transaction.h
@@ -14,7 +14,6 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-
 #pragma once
 
 #include <cstdint>
@@ -26,7 +25,6 @@
 
 #include "kudu/common/common.pb.h"
 #include "kudu/consensus/consensus.pb.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/tablet/tablet.pb.h"
 #include "kudu/tablet/transactions/transaction.h"
@@ -134,7 +132,7 @@ class AlterSchemaTransaction : public Transaction {
   AlterSchemaTransactionState* state() override { return state_.get(); }
   const AlterSchemaTransactionState* state() const override { return state_.get(); }
 
-  void NewReplicateMsg(gscoped_ptr<consensus::ReplicateMsg>* replicate_msg) override;
+  void NewReplicateMsg(std::unique_ptr<consensus::ReplicateMsg>* replicate_msg) override;
 
   // Executes a Prepare for the alter schema transaction.
   Status Prepare() override;
@@ -143,7 +141,7 @@ class AlterSchemaTransaction : public Transaction {
   Status Start() override;
 
   // Executes an Apply for the alter schema transaction
-  Status Apply(gscoped_ptr<consensus::CommitMsg>* commit_msg) override;
+  Status Apply(std::unique_ptr<consensus::CommitMsg>* commit_msg) override;
 
   // Actually commits the transaction.
   void Finish(TransactionResult result) override;
diff --git a/src/kudu/tablet/transactions/transaction.h b/src/kudu/tablet/transactions/transaction.h
index ba4b64d..1a3125d 100644
--- a/src/kudu/tablet/transactions/transaction.h
+++ b/src/kudu/tablet/transactions/transaction.h
@@ -18,6 +18,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <mutex>
 #include <string>
 
@@ -29,7 +30,6 @@
 #include "kudu/consensus/consensus.pb.h"
 #include "kudu/consensus/opid.pb.h"
 #include "kudu/consensus/raft_consensus.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/rpc/result_tracker.h"
@@ -101,7 +101,7 @@ class Transaction {
   TransactionType tx_type() const { return tx_type_; }
 
   // Builds the ReplicateMsg for this transaction.
-  virtual void NewReplicateMsg(gscoped_ptr<consensus::ReplicateMsg>* replicate_msg) = 0;
+  virtual void NewReplicateMsg(std::unique_ptr<consensus::ReplicateMsg>* replicate_msg) = 0;
 
   // Executes the prepare phase of this transaction, the actual actions
   // of this phase depend on the transaction type, but usually are limited
@@ -123,7 +123,7 @@ class Transaction {
   // Executes the Apply() phase of the transaction, the actual actions of
   // this phase depend on the transaction type, but usually this is the
   // method where data-structures are changed.
-  virtual Status Apply(gscoped_ptr<consensus::CommitMsg>* commit_msg) = 0;
+  virtual Status Apply(std::unique_ptr<consensus::CommitMsg>* commit_msg) = 0;
 
   // Executed after the transaction has been applied and the commit message has
   // been appended to the log (though it might not be durable yet), or if the
diff --git a/src/kudu/tablet/transactions/transaction_driver.cc b/src/kudu/tablet/transactions/transaction_driver.cc
index 2f4d9c0..c9d26e5 100644
--- a/src/kudu/tablet/transactions/transaction_driver.cc
+++ b/src/kudu/tablet/transactions/transaction_driver.cc
@@ -21,7 +21,6 @@
 #include <memory>
 #include <mutex>
 #include <ostream>
-#include <type_traits>
 #include <utility>
 
 #include <glog/logging.h>
@@ -29,10 +28,10 @@
 #include <google/protobuf/message.h>
 
 #include "kudu/clock/clock.h"
-#include "kudu/consensus/raft_consensus.h"
 #include "kudu/common/common.pb.h"
 #include "kudu/common/timestamp.h"
 #include "kudu/consensus/log.h"
+#include "kudu/consensus/raft_consensus.h"
 #include "kudu/consensus/time_manager.h"
 #include "kudu/gutil/bind.h"
 #include "kudu/gutil/bind_helpers.h"
@@ -125,7 +124,7 @@ TransactionDriver::TransactionDriver(TransactionTracker *txn_tracker,
   }
 }
 
-Status TransactionDriver::Init(gscoped_ptr<Transaction> transaction,
+Status TransactionDriver::Init(unique_ptr<Transaction> transaction,
                                DriverType type) {
   // If the tablet has been stopped, the replica is likely shutting down soon.
   // Prevent further transacions from starting.
@@ -165,7 +164,7 @@ Status TransactionDriver::Init(gscoped_ptr<Transaction> transaction,
     }
   } else {
     DCHECK_EQ(type, consensus::LEADER);
-    gscoped_ptr<ReplicateMsg> replicate_msg;
+    unique_ptr<ReplicateMsg> replicate_msg;
     transaction_->NewReplicateMsg(&replicate_msg);
     if (consensus_) { // sometimes NULL in tests
       // A raw pointer is required to avoid a refcount cycle.
@@ -517,7 +516,7 @@ void TransactionDriver::ApplyTask() {
   scoped_refptr<TransactionDriver> ref(this);
 
   {
-    gscoped_ptr<CommitMsg> commit_msg;
+    unique_ptr<CommitMsg> commit_msg;
     Status s = transaction_->Apply(&commit_msg);
     if (PREDICT_FALSE(!s.ok())) {
       LOG(WARNING) << Substitute("Did not Apply transaction $0: $1",
diff --git a/src/kudu/tablet/transactions/transaction_driver.h b/src/kudu/tablet/transactions/transaction_driver.h
index b661c02..05b680d 100644
--- a/src/kudu/tablet/transactions/transaction_driver.h
+++ b/src/kudu/tablet/transactions/transaction_driver.h
@@ -14,16 +14,15 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-
 #pragma once
 
+#include <memory>
 #include <string>
 
 #include <gtest/gtest_prod.h>
 
 #include "kudu/consensus/consensus.pb.h"
 #include "kudu/consensus/opid.pb.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/walltime.h"
@@ -34,9 +33,9 @@
 #include "kudu/util/trace.h"
 
 namespace kudu {
-class Timestamp;
 class ThreadPool;
 class ThreadPoolToken;
+class Timestamp;
 
 namespace log {
 class Log;
@@ -234,7 +233,7 @@ class TransactionDriver : public RefCountedThreadSafe<TransactionDriver> {
 
   // Perform any non-constructor initialization. Sets the transaction
   // that will be executed.
-  Status Init(gscoped_ptr<Transaction> transaction,
+  Status Init(std::unique_ptr<Transaction> transaction,
               consensus::DriverType type);
 
   // Returns the OpId of the transaction being executed or an uninitialized
@@ -375,7 +374,7 @@ class TransactionDriver : public RefCountedThreadSafe<TransactionDriver> {
   mutable simple_spinlock opid_lock_;
 
   // The transaction to be executed by this driver.
-  gscoped_ptr<Transaction> transaction_;
+  std::unique_ptr<Transaction> transaction_;
 
   // Trace object for tracing any transactions started by this driver.
   scoped_refptr<Trace> trace_;
diff --git a/src/kudu/tablet/transactions/transaction_tracker-test.cc b/src/kudu/tablet/transactions/transaction_tracker-test.cc
index d7b412e..f1481a8 100644
--- a/src/kudu/tablet/transactions/transaction_tracker-test.cc
+++ b/src/kudu/tablet/transactions/transaction_tracker-test.cc
@@ -31,7 +31,6 @@
 
 #include "kudu/consensus/consensus.pb.h"
 #include "kudu/gutil/casts.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/tablet/transactions/transaction.h"
 #include "kudu/tablet/transactions/transaction_driver.h"
@@ -57,6 +56,7 @@ METRIC_DECLARE_counter(transaction_memory_limit_rejections);
 
 using std::pair;
 using std::shared_ptr;
+using std::unique_ptr;
 using std::vector;
 
 namespace kudu {
@@ -80,7 +80,7 @@ class TransactionTrackerTest : public KuduTest,
         state_(state) {
     }
 
-    void NewReplicateMsg(gscoped_ptr<consensus::ReplicateMsg>* replicate_msg) override {
+    void NewReplicateMsg(unique_ptr<consensus::ReplicateMsg>* replicate_msg) override {
       replicate_msg->reset(new consensus::ReplicateMsg());
     }
     TransactionState* state() override { return state_.get();  }
@@ -88,14 +88,14 @@ class TransactionTrackerTest : public KuduTest,
 
     Status Prepare() override { return Status::OK(); }
     Status Start() override { return Status::OK(); }
-    Status Apply(gscoped_ptr<consensus::CommitMsg>* /* commit_msg */) override {
+    Status Apply(unique_ptr<consensus::CommitMsg>* /* commit_msg */) override {
       return Status::OK();
     }
     std::string ToString() const override {
       return "NoOp";
     }
    private:
-    gscoped_ptr<NoOpTransactionState> state_;
+    unique_ptr<NoOpTransactionState> state_;
   };
 
   TransactionTrackerTest()
@@ -116,8 +116,8 @@ class TransactionTrackerTest : public KuduTest,
                                 nullptr,
                                 nullptr,
                                 nullptr));
-      gscoped_ptr<NoOpTransaction> tx(new NoOpTransaction(new NoOpTransactionState));
-      RETURN_NOT_OK(driver->Init(tx.PassAs<Transaction>(), consensus::LEADER));
+      unique_ptr<NoOpTransaction> tx(new NoOpTransaction(new NoOpTransactionState));
+      RETURN_NOT_OK(driver->Init(std::move(tx), consensus::LEADER));
       local_drivers.push_back(driver);
     }
 
diff --git a/src/kudu/tablet/transactions/transaction_tracker.h b/src/kudu/tablet/transactions/transaction_tracker.h
index 93e1b9e..96ac8fd 100644
--- a/src/kudu/tablet/transactions/transaction_tracker.h
+++ b/src/kudu/tablet/transactions/transaction_tracker.h
@@ -14,16 +14,13 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-
-#ifndef KUDU_TABLET_TRANSACTION_TRACKER_H_
-#define KUDU_TABLET_TRANSACTION_TRACKER_H_
+#pragma once
 
 #include <cstdint>
 #include <memory>
 #include <unordered_map>
 #include <vector>
 
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/tablet/transactions/transaction_driver.h"
@@ -103,7 +100,7 @@ class TransactionTracker {
       ScopedRefPtrEqualToFunctor<TransactionDriver> > TxnMap;
   TxnMap pending_txns_;
 
-  gscoped_ptr<Metrics> metrics_;
+  std::unique_ptr<Metrics> metrics_;
 
   std::shared_ptr<MemTracker> mem_tracker_;
 
@@ -112,5 +109,3 @@ class TransactionTracker {
 
 }  // namespace tablet
 }  // namespace kudu
-
-#endif // KUDU_TABLET_TRANSACTION_TRACKER_H_
diff --git a/src/kudu/tablet/transactions/write_transaction.cc b/src/kudu/tablet/transactions/write_transaction.cc
index 2bfbbde..7350e92 100644
--- a/src/kudu/tablet/transactions/write_transaction.cc
+++ b/src/kudu/tablet/transactions/write_transaction.cc
@@ -22,7 +22,6 @@
 #include <ctime>
 #include <new>
 #include <ostream>
-#include <type_traits>
 #include <vector>
 
 #include <boost/optional/optional.hpp>
@@ -138,7 +137,7 @@ WriteTransaction::WriteTransaction(unique_ptr<WriteTransactionState> state, Driv
   start_time_ = MonoTime::Now();
 }
 
-void WriteTransaction::NewReplicateMsg(gscoped_ptr<ReplicateMsg>* replicate_msg) {
+void WriteTransaction::NewReplicateMsg(unique_ptr<ReplicateMsg>* replicate_msg) {
   replicate_msg->reset(new ReplicateMsg);
   (*replicate_msg)->set_op_type(WRITE_OP);
   (*replicate_msg)->mutable_write_request()->CopyFrom(*state()->request());
@@ -221,7 +220,7 @@ void WriteTransaction::UpdatePerRowErrors() {
 
 // FIXME: Since this is called as a void in a thread-pool callback,
 // it seems pointless to return a Status!
-Status WriteTransaction::Apply(gscoped_ptr<CommitMsg>* commit_msg) {
+Status WriteTransaction::Apply(unique_ptr<CommitMsg>* commit_msg) {
   TRACE_EVENT0("txn", "WriteTransaction::Apply");
   TRACE("APPLY: Starting.");
 
@@ -320,7 +319,7 @@ WriteTransactionState::WriteTransactionState(TabletReplica* tablet_replica,
   }
 }
 
-void WriteTransactionState::SetMvccTx(gscoped_ptr<ScopedTransaction> mvcc_tx) {
+void WriteTransactionState::SetMvccTx(unique_ptr<ScopedTransaction> mvcc_tx) {
   DCHECK(!mvcc_tx_) << "Mvcc transaction already started/set.";
   mvcc_tx_ = std::move(mvcc_tx);
 }
diff --git a/src/kudu/tablet/transactions/write_transaction.h b/src/kudu/tablet/transactions/write_transaction.h
index b6b6f5c..23c829a 100644
--- a/src/kudu/tablet/transactions/write_transaction.h
+++ b/src/kudu/tablet/transactions/write_transaction.h
@@ -29,7 +29,6 @@
 #include "kudu/common/row_operations.h"
 #include "kudu/common/wire_protocol.pb.h"
 #include "kudu/consensus/consensus.pb.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/tablet/rowset.h"
@@ -150,7 +149,7 @@ class WriteTransactionState : public TransactionState {
   // This must be called exactly once, after the timestamp was acquired.
   // This also copies the timestamp from the MVCC transaction into the
   // WriteTransactionState object.
-  void SetMvccTx(gscoped_ptr<ScopedTransaction> mvcc_tx);
+  void SetMvccTx(std::unique_ptr<ScopedTransaction> mvcc_tx);
 
   // Set the Tablet components that this transaction will write into.
   // Called exactly once at the beginning of Apply, before applying its
@@ -255,7 +254,7 @@ class WriteTransactionState : public TransactionState {
   ProbeStats* stats_array_ = nullptr;
 
   // The MVCC transaction, set up during PREPARE phase
-  gscoped_ptr<ScopedTransaction> mvcc_tx_;
+  std::unique_ptr<ScopedTransaction> mvcc_tx_;
 
   // The tablet components, acquired at the same time as mvcc_tx_ is set.
   scoped_refptr<const TabletComponents> tablet_components_;
@@ -281,7 +280,7 @@ class WriteTransaction : public Transaction {
   WriteTransactionState* state() override { return state_.get(); }
   const WriteTransactionState* state() const override { return state_.get(); }
 
-  void NewReplicateMsg(gscoped_ptr<consensus::ReplicateMsg>* replicate_msg) override;
+  void NewReplicateMsg(std::unique_ptr<consensus::ReplicateMsg>* replicate_msg) override;
 
   // Executes a Prepare for a write transaction.
   //
@@ -316,7 +315,7 @@ class WriteTransaction : public Transaction {
   // are placed in the queue (but not necessarily in the same order of the
   // original requests) which is already a requirement of the consensus
   // algorithm.
-  Status Apply(gscoped_ptr<consensus::CommitMsg>* commit_msg) override;
+  Status Apply(std::unique_ptr<consensus::CommitMsg>* commit_msg) override;
 
   // If result == COMMITTED, commits the mvcc transaction and updates
   // the metrics, if result == ABORTED aborts the mvcc transaction.
diff --git a/src/kudu/tools/ksck_remote-test.cc b/src/kudu/tools/ksck_remote-test.cc
index 0649060..ace10e2 100644
--- a/src/kudu/tools/ksck_remote-test.cc
+++ b/src/kudu/tools/ksck_remote-test.cc
@@ -21,11 +21,11 @@
 #include <memory>
 #include <sstream>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include <boost/core/ref.hpp>
 #include <gflags/gflags.h>
-#include <gflags/gflags_declare.h>
 #include <glog/logging.h>
 #include <gtest/gtest.h>
 
@@ -34,7 +34,6 @@
 #include "kudu/client/shared_ptr.h"
 #include "kudu/client/write_op.h"
 #include "kudu/common/partial_row.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/ref_counted.h"
@@ -126,7 +125,7 @@ class RemoteKsckTest : public KuduTest {
     ASSERT_OK(mini_cluster_->CreateClient(nullptr, &client_));
 
     // Create one table.
-    gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+    unique_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
     ASSERT_OK(table_creator->table_name(kTableName)
@@ -182,7 +181,7 @@ class RemoteKsckTest : public KuduTest {
     }
 
     for (uint64_t i = 0; continue_writing.Load(); i++) {
-      gscoped_ptr<KuduInsert> insert(table->NewInsert());
+      unique_ptr<KuduInsert> insert(table->NewInsert());
       GenerateDataForRow(table->schema(), i, &random_, insert->mutable_row());
       status = session->Apply(insert.release());
       if (!status.ok()) {
diff --git a/src/kudu/tools/ksck_remote.cc b/src/kudu/tools/ksck_remote.cc
index 0f3a1da..1afd91a 100644
--- a/src/kudu/tools/ksck_remote.cc
+++ b/src/kudu/tools/ksck_remote.cc
@@ -43,7 +43,6 @@
 #include "kudu/consensus/consensus.proxy.h"
 #include "kudu/consensus/metadata.pb.h"
 #include "kudu/gutil/basictypes.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -98,6 +97,7 @@ using kudu::rpc::MessengerBuilder;
 using kudu::rpc::RpcController;
 using std::shared_ptr;
 using std::string;
+using std::unique_ptr;
 using std::vector;
 using strings::Substitute;
 
@@ -387,7 +387,7 @@ class ChecksumStepper {
   }
 
   void HandleResponse() {
-    gscoped_ptr<ChecksumStepper> deleter(this);
+    unique_ptr<ChecksumStepper> deleter(this);
     Status s = rpc_.status();
     if (s.ok() && resp_.has_error()) {
       s = StatusFromPB(resp_.error().status());
@@ -453,7 +453,7 @@ class ChecksumStepper {
         LOG(FATAL) << "Unknown type";
         break;
     }
-    gscoped_ptr<ChecksumCallbackHandler> handler(new ChecksumCallbackHandler(this));
+    unique_ptr<ChecksumCallbackHandler> handler(new ChecksumCallbackHandler(this));
     rpc::ResponseCallback cb = boost::bind(&ChecksumCallbackHandler::Run, handler.get());
     proxy_->ChecksumAsync(req_, &resp_, &rpc_, cb);
     ignore_result(handler.release());
@@ -486,7 +486,7 @@ void RemoteKsckTabletServer::RunTabletChecksumScanAsync(
         const Schema& schema,
         const KsckChecksumOptions& options,
         shared_ptr<KsckChecksumManager> manager) {
-  gscoped_ptr<ChecksumStepper> stepper(
+  unique_ptr<ChecksumStepper> stepper(
       new ChecksumStepper(tablet_id, schema, uuid(), options, manager, ts_proxy_));
   stepper->Start();
   ignore_result(stepper.release()); // Deletes self on callback.
diff --git a/src/kudu/tools/kudu-admin-test.cc b/src/kudu/tools/kudu-admin-test.cc
index bb68170..c40021e 100644
--- a/src/kudu/tools/kudu-admin-test.cc
+++ b/src/kudu/tools/kudu-admin-test.cc
@@ -49,7 +49,6 @@
 #include "kudu/consensus/opid.pb.h"
 #include "kudu/consensus/quorum_util.h"
 #include "kudu/gutil/basictypes.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/join.h"
@@ -1672,7 +1671,7 @@ TEST_F(AdminCliTest, TestListTablesDetail) {
   // Add another table to test multiple tables output.
   const string kAnotherTableId = "TestAnotherTable";
   auto client_schema = KuduSchema::FromSchema(schema_);
-  gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+  unique_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
   ASSERT_OK(table_creator->table_name(kAnotherTableId)
            .schema(&client_schema)
            .set_range_partition_columns({ "key" })
diff --git a/src/kudu/tools/rebalancer_tool-test.cc b/src/kudu/tools/rebalancer_tool-test.cc
index 86dffc6..53de5ea 100644
--- a/src/kudu/tools/rebalancer_tool-test.cc
+++ b/src/kudu/tools/rebalancer_tool-test.cc
@@ -42,7 +42,6 @@
 #include "kudu/consensus/consensus.pb.h"
 #include "kudu/consensus/consensus.proxy.h"
 #include "kudu/consensus/quorum_util.h"
-#include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/join.h"
diff --git a/src/kudu/util/bit-stream-utils.h b/src/kudu/util/bit-stream-utils.h
index c6aeb01..a772c7c 100644
--- a/src/kudu/util/bit-stream-utils.h
+++ b/src/kudu/util/bit-stream-utils.h
@@ -14,8 +14,7 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef IMPALA_UTIL_BIT_STREAM_UTILS_H
-#define IMPALA_UTIL_BIT_STREAM_UTILS_H
+#pragma once
 
 #include "kudu/gutil/port.h"
 #include "kudu/util/bit-util.h"
@@ -93,7 +92,12 @@ class BitReader {
   // 'buffer' is the buffer to read from.  The buffer's length is 'buffer_len'.
   BitReader(const uint8_t* buffer, int buffer_len);
 
-  BitReader() : buffer_(NULL), max_bytes_(0) {}
+  BitReader()
+      : buffer_(nullptr),
+        max_bytes_(0),
+        buffered_values_(0),
+        byte_offset_(0),
+        bit_offset_(0) {}
 
   // Gets the next value from the buffer.  Returns true if 'v' could be read or false if
   // there are not enough bytes left. num_bits must be <= 32.
@@ -146,5 +150,3 @@ class BitReader {
 };
 
 } // namespace kudu
-
-#endif
diff --git a/src/kudu/util/bit-stream-utils.inline.h b/src/kudu/util/bit-stream-utils.inline.h
index d168bda..f9186f5 100644
--- a/src/kudu/util/bit-stream-utils.inline.h
+++ b/src/kudu/util/bit-stream-utils.inline.h
@@ -14,8 +14,7 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-#ifndef IMPALA_UTIL_BIT_STREAM_UTILS_INLINE_H
-#define IMPALA_UTIL_BIT_STREAM_UTILS_INLINE_H
+#pragma once
 
 #include <algorithm>
 
@@ -90,11 +89,11 @@ inline void BitWriter::PutVlqInt(int32_t v) {
 
 
 inline BitReader::BitReader(const uint8_t* buffer, int buffer_len)
-  : buffer_(buffer),
-    max_bytes_(buffer_len),
-    buffered_values_(0),
-    byte_offset_(0),
-    bit_offset_(0) {
+    : buffer_(buffer),
+      max_bytes_(buffer_len),
+      buffered_values_(0),
+      byte_offset_(0),
+      bit_offset_(0) {
   int num_bytes = std::min(8, max_bytes_);
   memcpy(&buffered_values_, buffer_ + byte_offset_, num_bytes);
 }
@@ -207,5 +206,3 @@ inline bool BitReader::GetVlqInt(int32_t* v) {
 }
 
 } // namespace kudu
-
-#endif
diff --git a/src/kudu/util/rle-encoding.h b/src/kudu/util/rle-encoding.h
index f3cf2c1..4a00148 100644
--- a/src/kudu/util/rle-encoding.h
+++ b/src/kudu/util/rle-encoding.h
@@ -84,17 +84,22 @@ class RleDecoder {
   // Create a decoder object. buffer/buffer_len is the decoded data.
   // bit_width is the width of each value (before encoding).
   RleDecoder(const uint8_t* buffer, int buffer_len, int bit_width)
-    : bit_reader_(buffer, buffer_len),
-      bit_width_(bit_width),
-      current_value_(0),
-      repeat_count_(0),
-      literal_count_(0),
-      rewind_state_(CANT_REWIND) {
+      : bit_reader_(buffer, buffer_len),
+        bit_width_(bit_width),
+        current_value_(0),
+        repeat_count_(0),
+        literal_count_(0),
+        rewind_state_(CANT_REWIND) {
     DCHECK_GE(bit_width_, 1);
     DCHECK_LE(bit_width_, 64);
   }
 
-  RleDecoder() {}
+  RleDecoder()
+      : bit_width_(0),
+        current_value_(0),
+        repeat_count_(0),
+        literal_count_(0),
+        rewind_state_(CANT_REWIND) {}
 
   // Skip n values, and returns the number of non-zero entries skipped.
   size_t Skip(size_t to_skip);


Mime
View raw message