diff --git a/update_manager/boxed_value.h b/update_manager/boxed_value.h
index 1ad9946..200464f 100644
--- a/update_manager/boxed_value.h
+++ b/update_manager/boxed_value.h
@@ -5,6 +5,7 @@
 #ifndef UPDATE_ENGINE_UPDATE_MANAGER_BOXED_VALUE_H_
 #define UPDATE_ENGINE_UPDATE_MANAGER_BOXED_VALUE_H_
 
+#include <memory>
 #include <string>
 
 #include <base/macros.h>
@@ -12,10 +13,10 @@
 namespace chromeos_update_manager {
 
 // BoxedValue is a class to hold pointers of a given type that deletes them when
-// the instance goes out of scope, as scoped_ptr<T> does. The main difference
-// with it is that the type T is not part of the class, i.e., this isn't a
-// parametric class. The class has a parametric constructor that accepts a
-// const T* which will define the type of the object passed on delete.
+// the instance goes out of scope, as std::unique_ptr<T> does. The main
+// difference with it is that the type T is not part of the class, i.e., this
+// isn't a parametric class. The class has a parametric constructor that accepts
+// a const T* which will define the type of the object passed on delete.
 //
 // It is safe to use this class in linked containers such as std::list and
 // std::map but the object can't be copied. This means that you need to
diff --git a/update_manager/default_policy.h b/update_manager/default_policy.h
index 6c1848f..1673609 100644
--- a/update_manager/default_policy.h
+++ b/update_manager/default_policy.h
@@ -5,6 +5,7 @@
 #ifndef UPDATE_ENGINE_UPDATE_MANAGER_DEFAULT_POLICY_H_
 #define UPDATE_ENGINE_UPDATE_MANAGER_DEFAULT_POLICY_H_
 
+#include <memory>
 #include <string>
 
 #include <base/time/time.h>
@@ -74,7 +75,7 @@
   chromeos_update_engine::ClockInterface* clock_;
 
   // An auxiliary state object.
-  scoped_ptr<DefaultPolicyState> aux_state_;
+  std::unique_ptr<DefaultPolicyState> aux_state_;
 
   DISALLOW_COPY_AND_ASSIGN(DefaultPolicy);
 };
diff --git a/update_manager/evaluation_context.cc b/update_manager/evaluation_context.cc
index e334560..9ab6771 100644
--- a/update_manager/evaluation_context.cc
+++ b/update_manager/evaluation_context.cc
@@ -5,6 +5,7 @@
 #include "update_engine/update_manager/evaluation_context.h"
 
 #include <algorithm>
+#include <memory>
 #include <string>
 
 #include <base/bind.h>
@@ -20,6 +21,7 @@
 using base::TimeDelta;
 using chromeos_update_engine::ClockInterface;
 using std::string;
+using std::unique_ptr;
 
 namespace {
 
@@ -52,11 +54,11 @@
     ClockInterface* clock,
     TimeDelta evaluation_timeout,
     TimeDelta expiration_timeout,
-    scoped_ptr<Callback<void(EvaluationContext*)>> unregister_cb)
+    unique_ptr<Callback<void(EvaluationContext*)>> unregister_cb)
     : clock_(clock),
       evaluation_timeout_(evaluation_timeout),
       expiration_timeout_(expiration_timeout),
-      unregister_cb_(unregister_cb.Pass()),
+      unregister_cb_(std::move(unregister_cb)),
       weak_ptr_factory_(this) {
   ResetEvaluation();
   ResetExpiration();
@@ -68,7 +70,7 @@
     unregister_cb_->Run(this);
 }
 
-scoped_ptr<Closure> EvaluationContext::RemoveObserversAndTimeout() {
+unique_ptr<Closure> EvaluationContext::RemoveObserversAndTimeout() {
   for (auto& it : value_cache_) {
     if (it.first->GetMode() == kVariableModeAsync)
       it.first->RemoveObserver(this);
@@ -76,7 +78,7 @@
   CancelMainLoopEvent(timeout_event_);
   timeout_event_ = kEventIdNull;
 
-  return scoped_ptr<Closure>(callback_.release());
+  return unique_ptr<Closure>(callback_.release());
 }
 
 TimeDelta EvaluationContext::RemainingTime(Time monotonic_deadline) const {
@@ -106,7 +108,7 @@
 
 void EvaluationContext::OnValueChangedOrTimeout() {
   // Copy the callback handle locally, allowing it to be reassigned.
-  scoped_ptr<Closure> callback = RemoveObserversAndTimeout();
+  unique_ptr<Closure> callback = RemoveObserversAndTimeout();
 
   if (callback.get())
     callback->Run();
diff --git a/update_manager/evaluation_context.h b/update_manager/evaluation_context.h
index a6d8f70..e7fba00 100644
--- a/update_manager/evaluation_context.h
+++ b/update_manager/evaluation_context.h
@@ -6,12 +6,12 @@
 #define UPDATE_ENGINE_UPDATE_MANAGER_EVALUATION_CONTEXT_H_
 
 #include <map>
+#include <memory>
 #include <string>
 
 #include <base/bind.h>
 #include <base/callback.h>
 #include <base/memory/ref_counted.h>
-#include <base/memory/scoped_ptr.h>
 #include <base/memory/weak_ptr.h>
 #include <base/time/time.h>
 
@@ -57,12 +57,12 @@
       chromeos_update_engine::ClockInterface* clock,
       base::TimeDelta evaluation_timeout,
       base::TimeDelta expiration_timeout,
-      scoped_ptr<base::Callback<void(EvaluationContext*)>> unregister_cb);
+      std::unique_ptr<base::Callback<void(EvaluationContext*)>> unregister_cb);
   EvaluationContext(chromeos_update_engine::ClockInterface* clock,
                     base::TimeDelta evaluation_timeout)
       : EvaluationContext(
           clock, evaluation_timeout, base::TimeDelta::Max(),
-          scoped_ptr<base::Callback<void(EvaluationContext*)>>()) {}
+          std::unique_ptr<base::Callback<void(EvaluationContext*)>>()) {}
   ~EvaluationContext();
 
   // Returns a pointer to the value returned by the passed variable |var|. The
@@ -113,7 +113,7 @@
   // Removes all the Observers callbacks and timeout events scheduled by
   // RunOnValueChangeOrTimeout(). Also releases and returns the closure
   // associated with these events. This method is idempotent.
-  scoped_ptr<base::Closure> RemoveObserversAndTimeout();
+  std::unique_ptr<base::Closure> RemoveObserversAndTimeout();
 
  private:
   friend class UmEvaluationContextTest;
@@ -147,7 +147,7 @@
   // timeout, or notifying about the evaluation context expiration. It is up to
   // the caller to determine whether or not expiration occurred via
   // is_expired().
-  scoped_ptr<base::Closure> callback_;
+  std::unique_ptr<base::Closure> callback_;
 
   // The EventId returned by the event loop identifying the timeout callback.
   // Used for canceling the timeout callback.
@@ -193,7 +193,7 @@
   base::Time expiration_monotonic_deadline_;
 
   // A callback for unregistering the context upon destruction.
-  scoped_ptr<base::Callback<void(EvaluationContext*)>> unregister_cb_;
+  std::unique_ptr<base::Callback<void(EvaluationContext*)>> unregister_cb_;
 
   base::WeakPtrFactory<EvaluationContext> weak_ptr_factory_;
 
diff --git a/update_manager/evaluation_context_unittest.cc b/update_manager/evaluation_context_unittest.cc
index e59b160..014d10c 100644
--- a/update_manager/evaluation_context_unittest.cc
+++ b/update_manager/evaluation_context_unittest.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
 #include <string>
 
 #include <base/bind.h>
@@ -23,6 +24,7 @@
 using chromeos_update_engine::RunGMainLoopMaxIterations;
 using chromeos_update_engine::RunGMainLoopUntil;
 using std::string;
+using std::unique_ptr;
 using testing::Return;
 using testing::StrictMock;
 using testing::_;
@@ -75,7 +77,7 @@
     fake_clock_.SetWallclockTime(Time::FromTimeT(1141262625));
     eval_ctx_ = new EvaluationContext(
         &fake_clock_, default_timeout_, default_timeout_,
-        scoped_ptr<base::Callback<void(EvaluationContext*)>>(nullptr));
+        unique_ptr<base::Callback<void(EvaluationContext*)>>(nullptr));
   }
 
   virtual void TearDown() {
diff --git a/update_manager/fake_variable.h b/update_manager/fake_variable.h
index 2dae3db..9459fac 100644
--- a/update_manager/fake_variable.h
+++ b/update_manager/fake_variable.h
@@ -5,10 +5,9 @@
 #ifndef UPDATE_ENGINE_UPDATE_MANAGER_FAKE_VARIABLE_H_
 #define UPDATE_ENGINE_UPDATE_MANAGER_FAKE_VARIABLE_H_
 
+#include <memory>
 #include <string>
 
-#include <base/memory/scoped_ptr.h>
-
 #include "update_engine/update_manager/variable.h"
 
 namespace chromeos_update_manager {
@@ -53,7 +52,7 @@
 
  private:
   // The pointer returned by GetValue().
-  scoped_ptr<const T> ptr_;
+  std::unique_ptr<const T> ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeVariable);
 };
diff --git a/update_manager/generic_variables_unittest.cc b/update_manager/generic_variables_unittest.cc
index 634acce..f0ea60c 100644
--- a/update_manager/generic_variables_unittest.cc
+++ b/update_manager/generic_variables_unittest.cc
@@ -4,8 +4,9 @@
 
 #include "update_engine/update_manager/generic_variables.h"
 
+#include <memory>
+
 #include <base/callback.h>
-#include <base/memory/scoped_ptr.h>
 #include <gtest/gtest.h>
 
 #include "update_engine/test_utils.h"
@@ -13,6 +14,7 @@
 
 using base::TimeDelta;
 using chromeos_update_engine::RunGMainLoopMaxIterations;
+using std::unique_ptr;
 
 namespace chromeos_update_manager {
 
@@ -25,7 +27,7 @@
   PollCopyVariable<int> var("var", source);
 
   // Generate and validate a copy.
-  scoped_ptr<const int> copy_1(var.GetValue(
+  unique_ptr<const int> copy_1(var.GetValue(
           UmTestUtils::DefaultTimeout(), nullptr));
   ASSERT_NE(nullptr, copy_1.get());
   EXPECT_EQ(5, *copy_1);
@@ -75,7 +77,7 @@
   ASSERT_FALSE(source.copied_);
 
   PollCopyVariable<CopyConstructorTestClass> var("var", source);
-  scoped_ptr<const CopyConstructorTestClass> copy(
+  unique_ptr<const CopyConstructorTestClass> copy(
       var.GetValue(UmTestUtils::DefaultTimeout(), nullptr));
   ASSERT_NE(nullptr, copy.get());
   EXPECT_TRUE(copy->copied_);
@@ -114,7 +116,7 @@
       test_func, &test_obj);
   CallCopyVariable<CopyConstructorTestClass> var("var", cb);
 
-  scoped_ptr<const CopyConstructorTestClass> copy(
+  unique_ptr<const CopyConstructorTestClass> copy(
       var.GetValue(UmTestUtils::DefaultTimeout(), nullptr));
   EXPECT_EQ(6, test_obj.val_);  // Check that the function was called.
   ASSERT_NE(nullptr, copy.get());
diff --git a/update_manager/real_config_provider.h b/update_manager/real_config_provider.h
index cc87c40..82c9284 100644
--- a/update_manager/real_config_provider.h
+++ b/update_manager/real_config_provider.h
@@ -5,10 +5,9 @@
 #ifndef UPDATE_ENGINE_UPDATE_MANAGER_REAL_CONFIG_PROVIDER_H_
 #define UPDATE_ENGINE_UPDATE_MANAGER_REAL_CONFIG_PROVIDER_H_
 
+#include <memory>
 #include <string>
 
-#include <base/memory/scoped_ptr.h>
-
 #include "update_engine/hardware_interface.h"
 #include "update_engine/update_manager/config_provider.h"
 #include "update_engine/update_manager/generic_variables.h"
@@ -39,7 +38,7 @@
     root_prefix_ = prefix;
   }
 
-  scoped_ptr<ConstCopyVariable<bool>> var_is_oobe_enabled_;
+  std::unique_ptr<ConstCopyVariable<bool>> var_is_oobe_enabled_;
 
   chromeos_update_engine::HardwareInterface* hardware_;
 
diff --git a/update_manager/real_config_provider_unittest.cc b/update_manager/real_config_provider_unittest.cc
index ab47d03..6e8d301 100644
--- a/update_manager/real_config_provider_unittest.cc
+++ b/update_manager/real_config_provider_unittest.cc
@@ -4,9 +4,10 @@
 
 #include "update_engine/update_manager/real_config_provider.h"
 
+#include <memory>
+
 #include <base/files/file_util.h>
 #include <base/files/scoped_temp_dir.h>
-#include <base/memory/scoped_ptr.h>
 #include <gtest/gtest.h>
 
 #include "update_engine/constants.h"
@@ -17,6 +18,7 @@
 using base::TimeDelta;
 using chromeos_update_engine::WriteFileString;
 using std::string;
+using std::unique_ptr;
 
 namespace chromeos_update_manager {
 
@@ -43,7 +45,7 @@
     ASSERT_TRUE(WriteFileString(kFile.value(), config));
   }
 
-  scoped_ptr<RealConfigProvider> provider_;
+  unique_ptr<RealConfigProvider> provider_;
   chromeos_update_engine::FakeHardware fake_hardware_;
   TimeDelta default_timeout_ = TimeDelta::FromSeconds(1);
   base::ScopedTempDir root_dir_;
diff --git a/update_manager/real_device_policy_provider_unittest.cc b/update_manager/real_device_policy_provider_unittest.cc
index 0f000a8..52b036b 100644
--- a/update_manager/real_device_policy_provider_unittest.cc
+++ b/update_manager/real_device_policy_provider_unittest.cc
@@ -4,7 +4,8 @@
 
 #include "update_engine/update_manager/real_device_policy_provider.h"
 
-#include <base/memory/scoped_ptr.h>
+#include <memory>
+
 #include <gtest/gtest.h>
 #include <policy/mock_device_policy.h>
 #include <policy/mock_libpolicy.h>
@@ -16,6 +17,7 @@
 using chromeos_update_engine::RunGMainLoopMaxIterations;
 using std::set;
 using std::string;
+using std::unique_ptr;
 using testing::AtLeast;
 using testing::DoAll;
 using testing::Mock;
@@ -60,7 +62,7 @@
 
   testing::NiceMock<policy::MockDevicePolicy> mock_device_policy_;
   testing::NiceMock<policy::MockPolicyProvider> mock_policy_provider_;
-  scoped_ptr<RealDevicePolicyProvider> provider_;
+  unique_ptr<RealDevicePolicyProvider> provider_;
 };
 
 TEST_F(UmRealDevicePolicyProviderTest, RefreshScheduledTest) {
diff --git a/update_manager/real_random_provider.h b/update_manager/real_random_provider.h
index 2e36d6f..d159933 100644
--- a/update_manager/real_random_provider.h
+++ b/update_manager/real_random_provider.h
@@ -5,7 +5,7 @@
 #ifndef UPDATE_ENGINE_UPDATE_MANAGER_REAL_RANDOM_PROVIDER_H_
 #define UPDATE_ENGINE_UPDATE_MANAGER_REAL_RANDOM_PROVIDER_H_
 
-#include <base/memory/scoped_ptr.h>
+#include <memory>
 
 #include "update_engine/update_manager/random_provider.h"
 
@@ -23,7 +23,7 @@
 
  private:
   // The seed() scoped variable.
-  scoped_ptr<Variable<uint64_t>> var_seed_;
+  std::unique_ptr<Variable<uint64_t>> var_seed_;
 
   DISALLOW_COPY_AND_ASSIGN(RealRandomProvider);
 };
diff --git a/update_manager/real_random_provider_unittest.cc b/update_manager/real_random_provider_unittest.cc
index b7e48f2..d7b2d98 100644
--- a/update_manager/real_random_provider_unittest.cc
+++ b/update_manager/real_random_provider_unittest.cc
@@ -2,13 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <base/memory/scoped_ptr.h>
 #include <gtest/gtest.h>
 
+#include <memory>
+
 #include "update_engine/update_manager/real_random_provider.h"
 #include "update_engine/update_manager/umtest_utils.h"
 
 using base::TimeDelta;
+using std::unique_ptr;
 
 namespace chromeos_update_manager {
 
@@ -23,7 +25,7 @@
     provider_->var_seed();
   }
 
-  scoped_ptr<RealRandomProvider> provider_;
+  unique_ptr<RealRandomProvider> provider_;
 };
 
 TEST_F(UmRealRandomProviderTest, InitFinalize) {
@@ -33,7 +35,7 @@
 
 TEST_F(UmRealRandomProviderTest, GetRandomValues) {
   // Should not return the same random seed repeatedly.
-  scoped_ptr<const uint64_t> value(
+  unique_ptr<const uint64_t> value(
       provider_->var_seed()->GetValue(UmTestUtils::DefaultTimeout(), nullptr));
   ASSERT_NE(nullptr, value.get());
 
@@ -41,7 +43,7 @@
   // by design, once every 2^320 runs.
   bool is_same_value = true;
   for (int i = 0; i < 5; i++) {
-    scoped_ptr<const uint64_t> other_value(
+    unique_ptr<const uint64_t> other_value(
         provider_->var_seed()->GetValue(UmTestUtils::DefaultTimeout(),
                                         nullptr));
     ASSERT_NE(nullptr, other_value.get());
diff --git a/update_manager/real_shill_provider_unittest.cc b/update_manager/real_shill_provider_unittest.cc
index 1cdc2a9..7c64d81 100644
--- a/update_manager/real_shill_provider_unittest.cc
+++ b/update_manager/real_shill_provider_unittest.cc
@@ -2,9 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
 #include <utility>
 
-#include <base/memory/scoped_ptr.h>
 #include <base/time/time.h>
 #include <chromeos/dbus/service_constants.h>
 #include <glib.h>
@@ -23,6 +23,7 @@
 using chromeos_update_engine::GValueNewString;
 using chromeos_update_engine::MockDBusWrapper;
 using std::pair;
+using std::unique_ptr;
 using testing::Eq;
 using testing::Mock;
 using testing::NiceMock;
@@ -294,7 +295,7 @@
 
   StrictMock<MockDBusWrapper> mock_dbus_;
   FakeClock fake_clock_;
-  scoped_ptr<RealShillProvider> provider_;
+  unique_ptr<RealShillProvider> provider_;
   void (*signal_handler_)(DBusGProxy*, const char*, GValue*, void*);
   void* signal_data_;
 };
diff --git a/update_manager/real_state.h b/update_manager/real_state.h
index 1e2d10e..824656f 100644
--- a/update_manager/real_state.h
+++ b/update_manager/real_state.h
@@ -5,7 +5,7 @@
 #ifndef UPDATE_ENGINE_UPDATE_MANAGER_REAL_STATE_H_
 #define UPDATE_ENGINE_UPDATE_MANAGER_REAL_STATE_H_
 
-#include <base/memory/scoped_ptr.h>
+#include <memory>
 
 #include "update_engine/update_manager/state.h"
 
@@ -56,13 +56,13 @@
 
  private:
   // Instances of the providers.
-  scoped_ptr<ConfigProvider> config_provider_;
-  scoped_ptr<DevicePolicyProvider> device_policy_provider_;
-  scoped_ptr<RandomProvider> random_provider_;
-  scoped_ptr<ShillProvider> shill_provider_;
-  scoped_ptr<SystemProvider> system_provider_;
-  scoped_ptr<TimeProvider> time_provider_;
-  scoped_ptr<UpdaterProvider> updater_provider_;
+  std::unique_ptr<ConfigProvider> config_provider_;
+  std::unique_ptr<DevicePolicyProvider> device_policy_provider_;
+  std::unique_ptr<RandomProvider> random_provider_;
+  std::unique_ptr<ShillProvider> shill_provider_;
+  std::unique_ptr<SystemProvider> system_provider_;
+  std::unique_ptr<TimeProvider> time_provider_;
+  std::unique_ptr<UpdaterProvider> updater_provider_;
 };
 
 }  // namespace chromeos_update_manager
diff --git a/update_manager/real_system_provider.h b/update_manager/real_system_provider.h
index c040855..9081d94 100644
--- a/update_manager/real_system_provider.h
+++ b/update_manager/real_system_provider.h
@@ -5,8 +5,7 @@
 #ifndef UPDATE_ENGINE_UPDATE_MANAGER_REAL_SYSTEM_PROVIDER_H_
 #define UPDATE_ENGINE_UPDATE_MANAGER_REAL_SYSTEM_PROVIDER_H_
 
-#include <base/memory/scoped_ptr.h>
-
+#include <memory>
 #include <string>
 
 #include "update_engine/hardware_interface.h"
@@ -41,10 +40,10 @@
   }
 
  private:
-  scoped_ptr<Variable<bool>> var_is_normal_boot_mode_;
-  scoped_ptr<Variable<bool>> var_is_official_build_;
-  scoped_ptr<Variable<bool>> var_is_oobe_complete_;
-  scoped_ptr<Variable<bool>> var_is_boot_device_removable_;
+  std::unique_ptr<Variable<bool>> var_is_normal_boot_mode_;
+  std::unique_ptr<Variable<bool>> var_is_official_build_;
+  std::unique_ptr<Variable<bool>> var_is_oobe_complete_;
+  std::unique_ptr<Variable<bool>> var_is_boot_device_removable_;
 
   chromeos_update_engine::HardwareInterface* hardware_;
 
diff --git a/update_manager/real_system_provider_unittest.cc b/update_manager/real_system_provider_unittest.cc
index f78d339..e370274 100644
--- a/update_manager/real_system_provider_unittest.cc
+++ b/update_manager/real_system_provider_unittest.cc
@@ -4,13 +4,16 @@
 
 #include "update_engine/update_manager/real_system_provider.h"
 
-#include <base/memory/scoped_ptr.h>
+#include <memory>
+
 #include <base/time/time.h>
 #include <gtest/gtest.h>
 
 #include "update_engine/fake_hardware.h"
 #include "update_engine/update_manager/umtest_utils.h"
 
+using std::unique_ptr;
+
 namespace chromeos_update_manager {
 
 class UmRealSystemProviderTest : public ::testing::Test {
@@ -21,7 +24,7 @@
   }
 
   chromeos_update_engine::FakeHardware fake_hardware_;
-  scoped_ptr<RealSystemProvider> provider_;
+  unique_ptr<RealSystemProvider> provider_;
 };
 
 TEST_F(UmRealSystemProviderTest, InitTest) {
diff --git a/update_manager/real_time_provider.h b/update_manager/real_time_provider.h
index ff5598e..63fc116 100644
--- a/update_manager/real_time_provider.h
+++ b/update_manager/real_time_provider.h
@@ -5,7 +5,8 @@
 #ifndef UPDATE_ENGINE_UPDATE_MANAGER_REAL_TIME_PROVIDER_H_
 #define UPDATE_ENGINE_UPDATE_MANAGER_REAL_TIME_PROVIDER_H_
 
-#include <base/memory/scoped_ptr.h>
+#include <memory>
+
 #include <base/time/time.h>
 
 #include "update_engine/clock_interface.h"
@@ -34,8 +35,8 @@
   // A clock abstraction (fakeable).
   chromeos_update_engine::ClockInterface* const clock_;
 
-  scoped_ptr<Variable<base::Time>> var_curr_date_;
-  scoped_ptr<Variable<int>> var_curr_hour_;
+  std::unique_ptr<Variable<base::Time>> var_curr_date_;
+  std::unique_ptr<Variable<int>> var_curr_hour_;
 
   DISALLOW_COPY_AND_ASSIGN(RealTimeProvider);
 };
diff --git a/update_manager/real_time_provider_unittest.cc b/update_manager/real_time_provider_unittest.cc
index ac47d39..da69e49 100644
--- a/update_manager/real_time_provider_unittest.cc
+++ b/update_manager/real_time_provider_unittest.cc
@@ -2,8 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
+
 #include <base/logging.h>
-#include <base/memory/scoped_ptr.h>
 #include <base/time/time.h>
 #include <gtest/gtest.h>
 
@@ -14,6 +15,7 @@
 using base::Time;
 using base::TimeDelta;
 using chromeos_update_engine::FakeClock;
+using std::unique_ptr;
 
 namespace chromeos_update_manager {
 
@@ -41,7 +43,7 @@
   }
 
   FakeClock fake_clock_;
-  scoped_ptr<RealTimeProvider> provider_;
+  unique_ptr<RealTimeProvider> provider_;
 };
 
 TEST_F(UmRealTimeProviderTest, CurrDateValid) {
diff --git a/update_manager/real_updater_provider.h b/update_manager/real_updater_provider.h
index c61032e..7317417 100644
--- a/update_manager/real_updater_provider.h
+++ b/update_manager/real_updater_provider.h
@@ -5,10 +5,9 @@
 #ifndef UPDATE_ENGINE_UPDATE_MANAGER_REAL_UPDATER_PROVIDER_H_
 #define UPDATE_ENGINE_UPDATE_MANAGER_REAL_UPDATER_PROVIDER_H_
 
+#include <memory>
 #include <string>
 
-#include <base/memory/scoped_ptr.h>
-
 #include "update_engine/system_state.h"
 #include "update_engine/update_manager/generic_variables.h"
 #include "update_engine/update_manager/updater_provider.h"
@@ -91,19 +90,19 @@
 
   // Variable implementations.
   ConstCopyVariable<base::Time> var_updater_started_time_;
-  scoped_ptr<Variable<base::Time>> var_last_checked_time_;
-  scoped_ptr<Variable<base::Time>> var_update_completed_time_;
-  scoped_ptr<Variable<double>> var_progress_;
-  scoped_ptr<Variable<Stage>> var_stage_;
-  scoped_ptr<Variable<std::string>> var_new_version_;
-  scoped_ptr<Variable<int64_t>> var_payload_size_;
-  scoped_ptr<Variable<std::string>> var_curr_channel_;
-  scoped_ptr<Variable<std::string>> var_new_channel_;
-  scoped_ptr<Variable<bool>> var_p2p_enabled_;
-  scoped_ptr<Variable<bool>> var_cellular_enabled_;
-  scoped_ptr<Variable<unsigned int>> var_consecutive_failed_update_checks_;
-  scoped_ptr<Variable<unsigned int>> var_server_dictated_poll_interval_;
-  scoped_ptr<Variable<UpdateRequestStatus>> var_forced_update_requested_;
+  std::unique_ptr<Variable<base::Time>> var_last_checked_time_;
+  std::unique_ptr<Variable<base::Time>> var_update_completed_time_;
+  std::unique_ptr<Variable<double>> var_progress_;
+  std::unique_ptr<Variable<Stage>> var_stage_;
+  std::unique_ptr<Variable<std::string>> var_new_version_;
+  std::unique_ptr<Variable<int64_t>> var_payload_size_;
+  std::unique_ptr<Variable<std::string>> var_curr_channel_;
+  std::unique_ptr<Variable<std::string>> var_new_channel_;
+  std::unique_ptr<Variable<bool>> var_p2p_enabled_;
+  std::unique_ptr<Variable<bool>> var_cellular_enabled_;
+  std::unique_ptr<Variable<unsigned int>> var_consecutive_failed_update_checks_;
+  std::unique_ptr<Variable<unsigned int>> var_server_dictated_poll_interval_;
+  std::unique_ptr<Variable<UpdateRequestStatus>> var_forced_update_requested_;
 
   DISALLOW_COPY_AND_ASSIGN(RealUpdaterProvider);
 };
diff --git a/update_manager/real_updater_provider_unittest.cc b/update_manager/real_updater_provider_unittest.cc
index 6d614da..ab0ee20 100644
--- a/update_manager/real_updater_provider_unittest.cc
+++ b/update_manager/real_updater_provider_unittest.cc
@@ -4,9 +4,9 @@
 
 #include "update_engine/update_manager/real_updater_provider.h"
 
+#include <memory>
 #include <string>
 
-#include <base/memory/scoped_ptr.h>
 #include <base/time/time.h>
 #include <chromeos/dbus/service_constants.h>
 #include <gtest/gtest.h>
@@ -26,6 +26,7 @@
 using chromeos_update_engine::PrefsMock;
 using chromeos_update_engine::UpdateAttempterMock;
 using std::string;
+using std::unique_ptr;
 using testing::Return;
 using testing::SetArgPointee;
 using testing::StrEq;
@@ -108,7 +109,7 @@
 
   FakeSystemState fake_sys_state_;
   FakeClock* fake_clock_;  // Short for fake_sys_state_.fake_clock()
-  scoped_ptr<RealUpdaterProvider> provider_;
+  unique_ptr<RealUpdaterProvider> provider_;
 };
 
 TEST_F(UmRealUpdaterProviderTest, UpdaterStartedTimeIsWallclockTime) {
diff --git a/update_manager/state_factory.cc b/update_manager/state_factory.cc
index e9b576a..745f0f5 100644
--- a/update_manager/state_factory.cc
+++ b/update_manager/state_factory.cc
@@ -4,8 +4,9 @@
 
 #include "update_engine/update_manager/state_factory.h"
 
+#include <memory>
+
 #include <base/logging.h>
-#include <base/memory/scoped_ptr.h>
 
 #include "update_engine/clock_interface.h"
 #include "update_engine/update_manager/real_config_provider.h"
@@ -17,23 +18,25 @@
 #include "update_engine/update_manager/real_time_provider.h"
 #include "update_engine/update_manager/real_updater_provider.h"
 
+using std::unique_ptr;
+
 namespace chromeos_update_manager {
 
 State* DefaultStateFactory(policy::PolicyProvider* policy_provider,
                            chromeos_update_engine::DBusWrapperInterface* dbus,
                            chromeos_update_engine::SystemState* system_state) {
   chromeos_update_engine::ClockInterface* const clock = system_state->clock();
-  scoped_ptr<RealConfigProvider> config_provider(
+  unique_ptr<RealConfigProvider> config_provider(
       new RealConfigProvider(system_state->hardware()));
-  scoped_ptr<RealDevicePolicyProvider> device_policy_provider(
+  unique_ptr<RealDevicePolicyProvider> device_policy_provider(
       new RealDevicePolicyProvider(policy_provider));
-  scoped_ptr<RealRandomProvider> random_provider(new RealRandomProvider());
-  scoped_ptr<RealShillProvider> shill_provider(
+  unique_ptr<RealRandomProvider> random_provider(new RealRandomProvider());
+  unique_ptr<RealShillProvider> shill_provider(
       new RealShillProvider(dbus, clock));
-  scoped_ptr<RealSystemProvider> system_provider(
+  unique_ptr<RealSystemProvider> system_provider(
       new RealSystemProvider(system_state->hardware()));
-  scoped_ptr<RealTimeProvider> time_provider(new RealTimeProvider(clock));
-  scoped_ptr<RealUpdaterProvider> updater_provider(
+  unique_ptr<RealTimeProvider> time_provider(new RealTimeProvider(clock));
+  unique_ptr<RealUpdaterProvider> updater_provider(
       new RealUpdaterProvider(system_state));
 
   if (!(config_provider->Init() &&
diff --git a/update_manager/umtest_utils.h b/update_manager/umtest_utils.h
index 4e2de8e..c50a5a2 100644
--- a/update_manager/umtest_utils.h
+++ b/update_manager/umtest_utils.h
@@ -6,8 +6,8 @@
 #define UPDATE_ENGINE_UPDATE_MANAGER_UMTEST_UTILS_H_
 
 #include <iostream>  // NOLINT(readability/streams)
+#include <memory>
 
-#include <base/memory/scoped_ptr.h>
 #include <base/time/time.h>
 #include <gtest/gtest.h>
 
@@ -28,7 +28,8 @@
   template<typename T>
   static void ExpectVariableHasValue(const T& expected, Variable<T>* variable) {
     ASSERT_NE(nullptr, variable);
-    scoped_ptr<const T> value(variable->GetValue(DefaultTimeout(), nullptr));
+    std::unique_ptr<const T> value(
+        variable->GetValue(DefaultTimeout(), nullptr));
     ASSERT_NE(nullptr, value.get()) << "Variable: " << variable->GetName();
     EXPECT_EQ(expected, *value) << "Variable: " << variable->GetName();
   }
@@ -37,7 +38,8 @@
   template<typename T>
   static void ExpectVariableNotSet(Variable<T>* variable) {
     ASSERT_NE(nullptr, variable);
-    scoped_ptr<const T> value(variable->GetValue(DefaultTimeout(), nullptr));
+    std::unique_ptr<const T> value(
+        variable->GetValue(DefaultTimeout(), nullptr));
     EXPECT_EQ(nullptr, value.get()) << "Variable: " << variable->GetName();
   }
 
diff --git a/update_manager/update_manager-inl.h b/update_manager/update_manager-inl.h
index a9f051f..5e30031 100644
--- a/update_manager/update_manager-inl.h
+++ b/update_manager/update_manager-inl.h
@@ -5,6 +5,7 @@
 #ifndef UPDATE_ENGINE_UPDATE_MANAGER_UPDATE_MANAGER_INL_H_
 #define UPDATE_ENGINE_UPDATE_MANAGER_UPDATE_MANAGER_INL_H_
 
+#include <memory>
 #include <string>
 
 #include <base/bind.h>
@@ -129,7 +130,7 @@
   scoped_refptr<EvaluationContext> ec =
       new EvaluationContext(
           clock_, evaluation_timeout_, expiration_timeout_,
-          scoped_ptr<base::Callback<void(EvaluationContext*)>>(
+          std::unique_ptr<base::Callback<void(EvaluationContext*)>>(
               new base::Callback<void(EvaluationContext*)>(
                   base::Bind(&UpdateManager::UnregisterEvalContext,
                              weak_ptr_factory_.GetWeakPtr()))));
diff --git a/update_manager/update_manager.h b/update_manager/update_manager.h
index 3355b60..cf7c6d5 100644
--- a/update_manager/update_manager.h
+++ b/update_manager/update_manager.h
@@ -5,12 +5,12 @@
 #ifndef UPDATE_ENGINE_UPDATE_MANAGER_UPDATE_MANAGER_H_
 #define UPDATE_ENGINE_UPDATE_MANAGER_UPDATE_MANAGER_H_
 
+#include <memory>
 #include <set>
 #include <string>
 
 #include <base/callback.h>
 #include <base/memory/ref_counted.h>
-#include <base/memory/scoped_ptr.h>
 #include <base/time/time.h>
 
 #include "update_engine/clock_interface.h"
@@ -127,14 +127,14 @@
 
   // The policy used by the UpdateManager. Note that since it is a const Policy,
   // policy implementations are not allowed to persist state on this class.
-  scoped_ptr<const Policy> policy_;
+  std::unique_ptr<const Policy> policy_;
 
   // A safe default value to the current policy. This policy is used whenever
   // a policy implementation fails with EvalStatus::kFailed.
   const DefaultPolicy default_policy_;
 
   // State Providers.
-  scoped_ptr<State> state_;
+  std::unique_ptr<State> state_;
 
   // Pointer to the mockable clock interface;
   chromeos_update_engine::ClockInterface* clock_;
diff --git a/update_manager/update_manager_unittest.cc b/update_manager/update_manager_unittest.cc
index 9e21716..b263fc8 100644
--- a/update_manager/update_manager_unittest.cc
+++ b/update_manager/update_manager_unittest.cc
@@ -5,13 +5,13 @@
 #include <unistd.h>
 
 #include <algorithm>
+#include <memory>
 #include <string>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 #include <base/bind.h>
-#include <base/memory/scoped_ptr.h>
 #include <base/time/time.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -33,6 +33,7 @@
 using std::pair;
 using std::string;
 using std::tuple;
+using std::unique_ptr;
 using std::vector;
 using testing::Return;
 using testing::StrictMock;
@@ -68,7 +69,7 @@
 
   FakeState* fake_state_;  // Owned by the umut_.
   FakeClock fake_clock_;
-  scoped_ptr<UpdateManager> umut_;
+  unique_ptr<UpdateManager> umut_;
 };
 
 // The FailingPolicy implements a single method and make it always fail. This