diff --git a/components/sync_sessions/fake_sync_sessions_client.cc b/components/sync_sessions/fake_sync_sessions_client.cc
index 9471d98efa8c67..8632a9347d4e1f 100644
--- a/components/sync_sessions/fake_sync_sessions_client.cc
+++ b/components/sync_sessions/fake_sync_sessions_client.cc
@@ -33,7 +33,7 @@ FakeSyncSessionsClient::GetSyncedWindowDelegatesGetter() {
   return nullptr;
 }
 
-scoped_ptr<browser_sync::LocalSessionEventRouter>
+std::unique_ptr<browser_sync::LocalSessionEventRouter>
 FakeSyncSessionsClient::GetLocalSessionEventRouter() {
   return nullptr;
 }
diff --git a/components/sync_sessions/fake_sync_sessions_client.h b/components/sync_sessions/fake_sync_sessions_client.h
index 5e332b8f05c11d..3bd4cc7a2cc6b0 100644
--- a/components/sync_sessions/fake_sync_sessions_client.h
+++ b/components/sync_sessions/fake_sync_sessions_client.h
@@ -23,8 +23,8 @@ class FakeSyncSessionsClient : public SyncSessionsClient {
   bool ShouldSyncURL(const GURL& url) const override;
   browser_sync::SyncedWindowDelegatesGetter* GetSyncedWindowDelegatesGetter()
       override;
-  scoped_ptr<browser_sync::LocalSessionEventRouter> GetLocalSessionEventRouter()
-      override;
+  std::unique_ptr<browser_sync::LocalSessionEventRouter>
+  GetLocalSessionEventRouter() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeSyncSessionsClient);
diff --git a/components/sync_sessions/favicon_cache.cc b/components/sync_sessions/favicon_cache.cc
index 6f62971b411500..6e07f47595b016 100644
--- a/components/sync_sessions/favicon_cache.cc
+++ b/components/sync_sessions/favicon_cache.cc
@@ -241,8 +241,8 @@ FaviconCache::~FaviconCache() {}
 syncer::SyncMergeResult FaviconCache::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
-    scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
-    scoped_ptr<syncer::SyncErrorFactory> error_handler) {
+    std::unique_ptr<syncer::SyncChangeProcessor> sync_processor,
+    std::unique_ptr<syncer::SyncErrorFactory> error_handler) {
   DCHECK(type == syncer::FAVICON_IMAGES || type == syncer::FAVICON_TRACKING);
   if (type == syncer::FAVICON_IMAGES)
     favicon_images_sync_processor_ = std::move(sync_processor);
diff --git a/components/sync_sessions/favicon_cache.h b/components/sync_sessions/favicon_cache.h
index 19202eaae93871..af478075606db2 100644
--- a/components/sync_sessions/favicon_cache.h
+++ b/components/sync_sessions/favicon_cache.h
@@ -9,6 +9,7 @@
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
@@ -19,7 +20,6 @@
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/task/cancelable_task_tracker.h"
@@ -69,8 +69,8 @@ class FaviconCache : public syncer::SyncableService,
   syncer::SyncMergeResult MergeDataAndStartSyncing(
       syncer::ModelType type,
       const syncer::SyncDataList& initial_sync_data,
-      scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
-      scoped_ptr<syncer::SyncErrorFactory> error_handler) override;
+      std::unique_ptr<syncer::SyncChangeProcessor> sync_processor,
+      std::unique_ptr<syncer::SyncErrorFactory> error_handler) override;
   void StopSyncing(syncer::ModelType type) override;
   syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const override;
   syncer::SyncError ProcessSyncChanges(
@@ -235,8 +235,8 @@ class FaviconCache : public syncer::SyncableService,
   // TODO(zea): consider creating a favicon handler here for fetching unsynced
   // favicons from the web.
 
-  scoped_ptr<syncer::SyncChangeProcessor> favicon_images_sync_processor_;
-  scoped_ptr<syncer::SyncChangeProcessor> favicon_tracking_sync_processor_;
+  std::unique_ptr<syncer::SyncChangeProcessor> favicon_images_sync_processor_;
+  std::unique_ptr<syncer::SyncChangeProcessor> favicon_tracking_sync_processor_;
 
   // Maximum number of favicons to sync. 0 means no limit.
   const size_t max_sync_favicon_limit_;
diff --git a/components/sync_sessions/favicon_cache_unittest.cc b/components/sync_sessions/favicon_cache_unittest.cc
index f42b8135f80ec6..0eb20923ed9af5 100644
--- a/components/sync_sessions/favicon_cache_unittest.cc
+++ b/components/sync_sessions/favicon_cache_unittest.cc
@@ -8,6 +8,7 @@
 #include <stdint.h>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ -276,8 +277,8 @@ class SyncFaviconCacheTest : public testing::Test {
   testing::AssertionResult VerifyLocalCustomIcons(
       const std::vector<TestFaviconData>& expected_icons);
 
-  scoped_ptr<syncer::SyncChangeProcessor> CreateAndPassProcessor();
-  scoped_ptr<syncer::SyncErrorFactory> CreateAndPassSyncErrorFactory();
+  std::unique_ptr<syncer::SyncChangeProcessor> CreateAndPassProcessor();
+  std::unique_ptr<syncer::SyncErrorFactory> CreateAndPassSyncErrorFactory();
 
   FaviconCache* cache() { return &cache_; }
   TestChangeProcessor* processor() { return sync_processor_.get(); }
@@ -297,8 +298,9 @@ class SyncFaviconCacheTest : public testing::Test {
   FaviconCache cache_;
 
   // Our dummy ChangeProcessor used to inspect changes pushed to Sync.
-  scoped_ptr<TestChangeProcessor> sync_processor_;
-  scoped_ptr<syncer::SyncChangeProcessorWrapperForTest> sync_processor_wrapper_;
+  std::unique_ptr<TestChangeProcessor> sync_processor_;
+  std::unique_ptr<syncer::SyncChangeProcessorWrapperForTest>
+      sync_processor_wrapper_;
 };
 
 SyncFaviconCacheTest::SyncFaviconCacheTest()
@@ -397,16 +399,15 @@ testing::AssertionResult SyncFaviconCacheTest::VerifyLocalCustomIcons(
   return testing::AssertionSuccess();
 }
 
-scoped_ptr<syncer::SyncChangeProcessor>
+std::unique_ptr<syncer::SyncChangeProcessor>
 SyncFaviconCacheTest::CreateAndPassProcessor() {
-  return scoped_ptr<syncer::SyncChangeProcessor>(
+  return base::WrapUnique(
       new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
 }
 
-scoped_ptr<syncer::SyncErrorFactory> SyncFaviconCacheTest::
-    CreateAndPassSyncErrorFactory() {
-  return scoped_ptr<syncer::SyncErrorFactory>(
-      new syncer::SyncErrorFactoryMock());
+std::unique_ptr<syncer::SyncErrorFactory>
+SyncFaviconCacheTest::CreateAndPassSyncErrorFactory() {
+  return base::WrapUnique(new syncer::SyncErrorFactoryMock);
 }
 
 void SyncFaviconCacheTest::OnCustomFaviconDataAvailable(
diff --git a/components/sync_sessions/revisit/bookmarks_page_revisit_observer.cc b/components/sync_sessions/revisit/bookmarks_page_revisit_observer.cc
index 20b44c909ac1ef..813348a85e9360 100644
--- a/components/sync_sessions/revisit/bookmarks_page_revisit_observer.cc
+++ b/components/sync_sessions/revisit/bookmarks_page_revisit_observer.cc
@@ -16,7 +16,7 @@
 namespace sync_sessions {
 
 BookmarksPageRevisitObserver::BookmarksPageRevisitObserver(
-    scoped_ptr<BookmarksByUrlProvider> provider)
+    std::unique_ptr<BookmarksByUrlProvider> provider)
     : provider_(std::move(provider)) {}
 
 BookmarksPageRevisitObserver::~BookmarksPageRevisitObserver() {}
diff --git a/components/sync_sessions/revisit/bookmarks_page_revisit_observer.h b/components/sync_sessions/revisit/bookmarks_page_revisit_observer.h
index 4d86b468532f96..6953755030f065 100644
--- a/components/sync_sessions/revisit/bookmarks_page_revisit_observer.h
+++ b/components/sync_sessions/revisit/bookmarks_page_revisit_observer.h
@@ -5,10 +5,10 @@
 #ifndef COMPONENTS_SYNC_SESSIONS_REVISIT_BOOKMARKS_PAGE_REVISIT_OBSERVER_H_
 #define COMPONENTS_SYNC_SESSIONS_REVISIT_BOOKMARKS_PAGE_REVISIT_OBSERVER_H_
 
+#include <memory>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "components/sync_sessions/revisit/page_visit_observer.h"
 
 class GURL;
@@ -40,12 +40,12 @@ class BookmarksByUrlProvider {
 class BookmarksPageRevisitObserver : public sync_sessions::PageVisitObserver {
  public:
   explicit BookmarksPageRevisitObserver(
-      scoped_ptr<BookmarksByUrlProvider> provider);
+      std::unique_ptr<BookmarksByUrlProvider> provider);
   ~BookmarksPageRevisitObserver() override;
   void OnPageVisit(const GURL& url, const TransitionType transition) override;
 
  private:
-  scoped_ptr<BookmarksByUrlProvider> provider_;
+  std::unique_ptr<BookmarksByUrlProvider> provider_;
   DISALLOW_COPY_AND_ASSIGN(BookmarksPageRevisitObserver);
 };
 
diff --git a/components/sync_sessions/revisit/bookmarks_page_revisit_observer_unittest.cc b/components/sync_sessions/revisit/bookmarks_page_revisit_observer_unittest.cc
index 59ed0e0c0cfce9..a6e887ec3a1a63 100644
--- a/components/sync_sessions/revisit/bookmarks_page_revisit_observer_unittest.cc
+++ b/components/sync_sessions/revisit/bookmarks_page_revisit_observer_unittest.cc
@@ -4,9 +4,10 @@
 
 #include "components/sync_sessions/revisit/bookmarks_page_revisit_observer.h"
 
+#include <memory>
 #include <vector>
 
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/test/histogram_tester.h"
 #include "components/bookmarks/browser/bookmark_node.h"
 #include "components/sync_sessions/revisit/page_visit_observer.h"
@@ -37,8 +38,8 @@ class TestBookmarksByUrlProvider : public BookmarksByUrlProvider {
 }  // namespace
 
 void RunObserver(const std::vector<const bookmarks::BookmarkNode*>& nodes) {
-  BookmarksPageRevisitObserver observer(scoped_ptr<BookmarksByUrlProvider>(
-      new TestBookmarksByUrlProvider(nodes)));
+  BookmarksPageRevisitObserver observer(
+      base::WrapUnique(new TestBookmarksByUrlProvider(nodes)));
   observer.OnPageVisit(kExampleGurl, PageVisitObserver::kTransitionPage);
 }
 
diff --git a/components/sync_sessions/revisit/current_tab_matcher_unittest.cc b/components/sync_sessions/revisit/current_tab_matcher_unittest.cc
index f61554c87679c5..600ee7e311c72d 100644
--- a/components/sync_sessions/revisit/current_tab_matcher_unittest.cc
+++ b/components/sync_sessions/revisit/current_tab_matcher_unittest.cc
@@ -4,9 +4,9 @@
 
 #include "components/sync_sessions/revisit/current_tab_matcher.h"
 
+#include <memory>
 #include <string>
 
-#include "base/memory/scoped_ptr.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "components/sessions/core/serialized_navigation_entry.h"
@@ -31,8 +31,8 @@ sessions::SerializedNavigationEntry Entry(const std::string& url) {
                                                                          "");
 }
 
-scoped_ptr<SessionTab> Tab(const int index, const base::Time timestamp) {
-  scoped_ptr<SessionTab> tab(new SessionTab());
+std::unique_ptr<SessionTab> Tab(const int index, const base::Time timestamp) {
+  std::unique_ptr<SessionTab> tab(new SessionTab());
   tab->current_navigation_index = index;
   tab->timestamp = timestamp;
   return tab;
@@ -61,14 +61,14 @@ TEST(CurrentTabMatcherTest, NoCheck) {
 }
 
 TEST(CurrentTabMatcherTest, EmptyTab) {
-  scoped_ptr<SessionTab> tab = Tab(0, base::Time::Now());
+  std::unique_ptr<SessionTab> tab = Tab(0, base::Time::Now());
   CurrentTabMatcher matcher((PageEquality(GURL(kExampleUrl))));
   matcher.Check(tab.get());
   VerifyMiss(&matcher);
 }
 
 TEST(CurrentTabMatcherTest, SameUrl) {
-  scoped_ptr<SessionTab> tab = Tab(0, base::Time::Now());
+  std::unique_ptr<SessionTab> tab = Tab(0, base::Time::Now());
   tab->navigations.push_back(Entry(kExampleUrl));
 
   CurrentTabMatcher matcher((PageEquality(GURL(kExampleUrl))));
@@ -77,7 +77,7 @@ TEST(CurrentTabMatcherTest, SameUrl) {
 }
 
 TEST(CurrentTabMatcherTest, DifferentUrl) {
-  scoped_ptr<SessionTab> tab = Tab(0, base::Time::Now());
+  std::unique_ptr<SessionTab> tab = Tab(0, base::Time::Now());
   tab->navigations.push_back(Entry(kDifferentUrl));
 
   CurrentTabMatcher matcher((PageEquality(GURL(kExampleUrl))));
@@ -86,7 +86,7 @@ TEST(CurrentTabMatcherTest, DifferentUrl) {
 }
 
 TEST(CurrentTabMatcherTest, DifferentIndex) {
-  scoped_ptr<SessionTab> tab = Tab(0, base::Time::Now());
+  std::unique_ptr<SessionTab> tab = Tab(0, base::Time::Now());
   tab->navigations.push_back(Entry(kDifferentUrl));
   tab->navigations.push_back(Entry(kExampleUrl));
 
@@ -96,10 +96,10 @@ TEST(CurrentTabMatcherTest, DifferentIndex) {
 }
 
 TEST(CurrentTabMatcherTest, Timestamp) {
-  scoped_ptr<SessionTab> tab1 = Tab(0, base::Time::UnixEpoch());
+  std::unique_ptr<SessionTab> tab1 = Tab(0, base::Time::UnixEpoch());
   tab1->navigations.push_back(Entry(kExampleUrl));
 
-  scoped_ptr<SessionTab> tab2 = Tab(0, base::Time::Now());
+  std::unique_ptr<SessionTab> tab2 = Tab(0, base::Time::Now());
   tab2->navigations.push_back(Entry(kExampleUrl));
 
   CurrentTabMatcher matcher1((PageEquality(GURL(kExampleUrl))));
diff --git a/components/sync_sessions/revisit/offset_tab_matcher_unittest.cc b/components/sync_sessions/revisit/offset_tab_matcher_unittest.cc
index f74c50f2a4edc1..c2b7a08c469a9b 100644
--- a/components/sync_sessions/revisit/offset_tab_matcher_unittest.cc
+++ b/components/sync_sessions/revisit/offset_tab_matcher_unittest.cc
@@ -4,9 +4,9 @@
 
 #include "components/sync_sessions/revisit/offset_tab_matcher.h"
 
+#include <memory>
 #include <string>
 
-#include "base/memory/scoped_ptr.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "components/sessions/core/serialized_navigation_entry.h"
@@ -31,9 +31,10 @@ sessions::SerializedNavigationEntry Entry(const std::string& url) {
                                                                          "");
 }
 
-scoped_ptr<SessionTab> Tab(const int index,
-                           const base::Time timestamp = base::Time::Now()) {
-  scoped_ptr<SessionTab> tab(new SessionTab());
+std::unique_ptr<SessionTab> Tab(
+    const int index,
+    const base::Time timestamp = base::Time::Now()) {
+  std::unique_ptr<SessionTab> tab(new SessionTab());
   tab->current_navigation_index = index;
   tab->timestamp = timestamp;
   return tab;
@@ -66,14 +67,14 @@ TEST(OffsetTabMatcherTest, NoCheck) {
 }
 
 TEST(OffsetTabMatcherTest, EmptyTab) {
-  scoped_ptr<SessionTab> tab = Tab(0);
+  std::unique_ptr<SessionTab> tab = Tab(0);
   OffsetTabMatcher matcher((PageEquality(GURL(kExampleUrl))));
   matcher.Check(tab.get());
   VerifyMiss(&matcher);
 }
 
 TEST(OffsetTabMatcherTest, HasMatchForward) {
-  scoped_ptr<SessionTab> tab = Tab(0);
+  std::unique_ptr<SessionTab> tab = Tab(0);
   tab->navigations.push_back(Entry(kDifferentUrl));
   tab->navigations.push_back(Entry(kExampleUrl));
 
@@ -83,7 +84,7 @@ TEST(OffsetTabMatcherTest, HasMatchForward) {
 }
 
 TEST(OffsetTabMatcherTest, HasMatchBackward) {
-  scoped_ptr<SessionTab> tab = Tab(1);
+  std::unique_ptr<SessionTab> tab = Tab(1);
   tab->navigations.push_back(Entry(kExampleUrl));
   tab->navigations.push_back(Entry(kDifferentUrl));
 
@@ -93,7 +94,7 @@ TEST(OffsetTabMatcherTest, HasMatchBackward) {
 }
 
 TEST(OffsetTabMatcherTest, NoMatch) {
-  scoped_ptr<SessionTab> tab = Tab(0);
+  std::unique_ptr<SessionTab> tab = Tab(0);
   tab->navigations.push_back(Entry(kExampleUrl));
   tab->navigations.push_back(Entry(kDifferentUrl));
 
@@ -103,7 +104,7 @@ TEST(OffsetTabMatcherTest, NoMatch) {
 }
 
 TEST(OffsetTabMatcherTest, MultipleBackwardOffsets) {
-  scoped_ptr<SessionTab> tab = Tab(4);
+  std::unique_ptr<SessionTab> tab = Tab(4);
   tab->navigations.push_back(Entry(kExampleUrl));
   tab->navigations.push_back(Entry(kExampleUrl));
   tab->navigations.push_back(Entry(kExampleUrl));  // Expected.
@@ -116,7 +117,7 @@ TEST(OffsetTabMatcherTest, MultipleBackwardOffsets) {
 }
 
 TEST(OffsetTabMatcherTest, MultipleOffsets) {
-  scoped_ptr<SessionTab> tab = Tab(1);
+  std::unique_ptr<SessionTab> tab = Tab(1);
   tab->navigations.push_back(Entry(kExampleUrl));
   tab->navigations.push_back(Entry(kExampleUrl));  // Current.
   tab->navigations.push_back(Entry(kExampleUrl));
@@ -129,7 +130,7 @@ TEST(OffsetTabMatcherTest, MultipleOffsets) {
 }
 
 TEST(OffsetTabMatcherTest, VeryForwardOffset) {
-  scoped_ptr<SessionTab> tab = Tab(0);
+  std::unique_ptr<SessionTab> tab = Tab(0);
   for (int i = 0; i < 20; i++) {
     tab->navigations.push_back(Entry(kDifferentUrl));
   }
@@ -142,7 +143,7 @@ TEST(OffsetTabMatcherTest, VeryForwardOffset) {
 }
 
 TEST(OffsetTabMatcherTest, VeryBackwardOffset) {
-  scoped_ptr<SessionTab> tab = Tab(20);
+  std::unique_ptr<SessionTab> tab = Tab(20);
   tab->navigations.push_back(Entry(kExampleUrl));
   for (int i = 0; i < 20; i++) {
     tab->navigations.push_back(Entry(kDifferentUrl));
@@ -155,11 +156,11 @@ TEST(OffsetTabMatcherTest, VeryBackwardOffset) {
 }
 
 TEST(OffsetTabMatcherTest, MultipleTabs) {
-  scoped_ptr<SessionTab> tab1 = Tab(0, base::Time::UnixEpoch());
+  std::unique_ptr<SessionTab> tab1 = Tab(0, base::Time::UnixEpoch());
   tab1->navigations.push_back(Entry(kExampleUrl));
   tab1->navigations.push_back(Entry(kExampleUrl));
 
-  scoped_ptr<SessionTab> tab2 = Tab(1, base::Time::Now());
+  std::unique_ptr<SessionTab> tab2 = Tab(1, base::Time::Now());
   tab2->navigations.push_back(Entry(kExampleUrl));
   tab2->navigations.push_back(Entry(kExampleUrl));
 
@@ -172,11 +173,11 @@ TEST(OffsetTabMatcherTest, MultipleTabs) {
 TEST(OffsetTabMatcherTest, MultipleTabsSameTime) {
   base::Time shared_now = base::Time::Now();
 
-  scoped_ptr<SessionTab> tab1 = Tab(0, shared_now);
+  std::unique_ptr<SessionTab> tab1 = Tab(0, shared_now);
   tab1->navigations.push_back(Entry(kExampleUrl));
   tab1->navigations.push_back(Entry(kExampleUrl));
 
-  scoped_ptr<SessionTab> tab2 = Tab(1, shared_now);
+  std::unique_ptr<SessionTab> tab2 = Tab(1, shared_now);
   tab2->navigations.push_back(Entry(kExampleUrl));
   tab2->navigations.push_back(Entry(kExampleUrl));
 
diff --git a/components/sync_sessions/revisit/page_revisit_broadcaster.cc b/components/sync_sessions/revisit/page_revisit_broadcaster.cc
index 6b5767c1682a5b..66fe702c596e8f 100644
--- a/components/sync_sessions/revisit/page_revisit_broadcaster.cc
+++ b/components/sync_sessions/revisit/page_revisit_broadcaster.cc
@@ -4,11 +4,12 @@
 
 #include "components/sync_sessions/revisit/page_revisit_broadcaster.h"
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/history/core/browser/history_service.h"
@@ -53,8 +54,7 @@ PageRevisitBroadcaster::PageRevisitBroadcaster(
   bool shouldInstrument = group_name == "Enabled";
   if (shouldInstrument) {
     revisit_observers_.push_back(new sync_sessions::SessionsPageRevisitObserver(
-        scoped_ptr<sync_sessions::ForeignSessionsProvider>(
-            new SessionsSyncManagerWrapper(manager))));
+        base::WrapUnique(new SessionsSyncManagerWrapper(manager))));
 
     history::HistoryService* history = sessions_client_->GetHistoryService();
     if (history) {
@@ -65,9 +65,8 @@ PageRevisitBroadcaster::PageRevisitBroadcaster(
     bookmarks::BookmarkModel* bookmarks = sessions_client_->GetBookmarkModel();
     if (bookmarks) {
       revisit_observers_.push_back(
-          new sync_sessions::BookmarksPageRevisitObserver(
-              scoped_ptr<sync_sessions::BookmarksByUrlProvider>(
-                  new sync_sessions::BookmarksByUrlProviderImpl(bookmarks))));
+          new sync_sessions::BookmarksPageRevisitObserver(base::WrapUnique(
+              new sync_sessions::BookmarksByUrlProviderImpl(bookmarks))));
     }
   }
 }
diff --git a/components/sync_sessions/revisit/sessions_page_revisit_observer.cc b/components/sync_sessions/revisit/sessions_page_revisit_observer.cc
index 36a9a6c32e42c4..cedf965475b476 100644
--- a/components/sync_sessions/revisit/sessions_page_revisit_observer.cc
+++ b/components/sync_sessions/revisit/sessions_page_revisit_observer.cc
@@ -19,7 +19,7 @@
 namespace sync_sessions {
 
 SessionsPageRevisitObserver::SessionsPageRevisitObserver(
-    scoped_ptr<ForeignSessionsProvider> provider)
+    std::unique_ptr<ForeignSessionsProvider> provider)
     : provider_(std::move(provider)) {}
 
 SessionsPageRevisitObserver::~SessionsPageRevisitObserver() {}
diff --git a/components/sync_sessions/revisit/sessions_page_revisit_observer.h b/components/sync_sessions/revisit/sessions_page_revisit_observer.h
index defe7343eb6588..294e9c8bddde78 100644
--- a/components/sync_sessions/revisit/sessions_page_revisit_observer.h
+++ b/components/sync_sessions/revisit/sessions_page_revisit_observer.h
@@ -5,10 +5,10 @@
 #ifndef COMPONENTS_SYNC_SESSIONS_REVISIT_SESSIONS_PAGE_REVISIT_OBSERVER_H_
 #define COMPONENTS_SYNC_SESSIONS_REVISIT_SESSIONS_PAGE_REVISIT_OBSERVER_H_
 
+#include <memory>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "components/sync_sessions/revisit/page_visit_observer.h"
 
@@ -47,7 +47,7 @@ class SessionsPageRevisitObserver
       public base::SupportsWeakPtr<SessionsPageRevisitObserver> {
  public:
   explicit SessionsPageRevisitObserver(
-      scoped_ptr<ForeignSessionsProvider> provider);
+      std::unique_ptr<ForeignSessionsProvider> provider);
   ~SessionsPageRevisitObserver() override;
   void OnPageVisit(const GURL& url, const TransitionType transition) override;
 
@@ -59,7 +59,7 @@ class SessionsPageRevisitObserver
   // target of a PostTask call coming from OnPageVisit(...).
   void CheckForRevisit(const GURL& url, const TransitionType transition);
 
-  scoped_ptr<ForeignSessionsProvider> provider_;
+  std::unique_ptr<ForeignSessionsProvider> provider_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionsPageRevisitObserver);
 };
diff --git a/components/sync_sessions/revisit/sessions_page_revisit_observer_unittest.cc b/components/sync_sessions/revisit/sessions_page_revisit_observer_unittest.cc
index 47604479b9aaaa..179895e35c2cb0 100644
--- a/components/sync_sessions/revisit/sessions_page_revisit_observer_unittest.cc
+++ b/components/sync_sessions/revisit/sessions_page_revisit_observer_unittest.cc
@@ -4,9 +4,10 @@
 
 #include "components/sync_sessions/revisit/sessions_page_revisit_observer.h"
 
+#include <memory>
 #include <string>
 
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/test/histogram_tester.h"
 #include "components/sessions/core/serialized_navigation_entry.h"
 #include "components/sessions/core/serialized_navigation_entry_test_helper.h"
@@ -75,7 +76,7 @@ class SessionsPageRevisitObserverTest : public ::testing::Test {
     std::vector<const SyncedSession*> sessions;
     sessions.push_back(session);
     SessionsPageRevisitObserver observer(
-        make_scoped_ptr(new TestForeignSessionsProvider(sessions, true)));
+        base::WrapUnique(new TestForeignSessionsProvider(sessions, true)));
     CheckAndExpect(&observer, url, current_match, offset_match);
   }
 };
@@ -83,44 +84,44 @@ class SessionsPageRevisitObserverTest : public ::testing::Test {
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoSessions) {
   std::vector<const SyncedSession*> sessions;
   SessionsPageRevisitObserver observer(
-      make_scoped_ptr(new TestForeignSessionsProvider(sessions, true)));
+      base::WrapUnique(new TestForeignSessionsProvider(sessions, true)));
   CheckAndExpect(&observer, GURL(kExampleUrl), false, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoWindows) {
-  scoped_ptr<SyncedSession> session(new SyncedSession());
+  std::unique_ptr<SyncedSession> session(new SyncedSession());
   CheckAndExpect(session.get(), GURL(kExampleUrl), false, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoTabs) {
-  scoped_ptr<SyncedSession> session(new SyncedSession());
+  std::unique_ptr<SyncedSession> session(new SyncedSession());
   session->windows[0] = new SessionWindow();
   CheckAndExpect(session.get(), GURL(kExampleUrl), false, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoEntries) {
-  scoped_ptr<SessionWindow> window(new SessionWindow());
+  std::unique_ptr<SessionWindow> window(new SessionWindow());
   window->tabs.push_back(new SessionTab());
-  scoped_ptr<SyncedSession> session(new SyncedSession());
+  std::unique_ptr<SyncedSession> session(new SyncedSession());
   session->windows[0] = window.release();
   CheckAndExpect(session.get(), GURL(kExampleUrl), false, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersSingle) {
-  scoped_ptr<SessionTab> tab(new SessionTab());
+  std::unique_ptr<SessionTab> tab(new SessionTab());
   tab->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
   tab->current_navigation_index = 0;
-  scoped_ptr<SessionWindow> window(new SessionWindow());
+  std::unique_ptr<SessionWindow> window(new SessionWindow());
   window->tabs.push_back(tab.release());
-  scoped_ptr<SyncedSession> session(new SyncedSession());
+  std::unique_ptr<SyncedSession> session(new SyncedSession());
   session->windows[0] = window.release();
   CheckAndExpect(session.get(), GURL(kExampleUrl), true, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersFalseProvider) {
-  scoped_ptr<SessionTab> tab(new SessionTab());
+  std::unique_ptr<SessionTab> tab(new SessionTab());
   tab->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
@@ -128,9 +129,9 @@ TEST_F(SessionsPageRevisitObserverTest, RunMatchersFalseProvider) {
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
   tab->current_navigation_index = 1;
-  scoped_ptr<SessionWindow> window(new SessionWindow());
+  std::unique_ptr<SessionWindow> window(new SessionWindow());
   window->tabs.push_back(tab.release());
-  scoped_ptr<SyncedSession> session(new SyncedSession());
+  std::unique_ptr<SyncedSession> session(new SyncedSession());
   session->windows[0] = window.release();
 
   // The provider returns false when asked for foreign sessions, even though
@@ -138,30 +139,30 @@ TEST_F(SessionsPageRevisitObserverTest, RunMatchersFalseProvider) {
   std::vector<const SyncedSession*> sessions;
   sessions.push_back(session.get());
   SessionsPageRevisitObserver observer(
-      make_scoped_ptr(new TestForeignSessionsProvider(sessions, false)));
+      base::WrapUnique(new TestForeignSessionsProvider(sessions, false)));
   CheckAndExpect(&observer, GURL(kExampleUrl), false, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersMany) {
-  scoped_ptr<SessionTab> tab1(new SessionTab());
+  std::unique_ptr<SessionTab> tab1(new SessionTab());
   tab1->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
   tab1->current_navigation_index = 0;
 
-  scoped_ptr<SessionTab> tab2(new SessionTab());
+  std::unique_ptr<SessionTab> tab2(new SessionTab());
   tab2->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kDifferentUrl, ""));
   tab2->current_navigation_index = 0;
 
-  scoped_ptr<SessionTab> tab3(new SessionTab());
+  std::unique_ptr<SessionTab> tab3(new SessionTab());
   tab3->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kDifferentUrl, ""));
   tab3->current_navigation_index = 0;
 
-  scoped_ptr<SessionTab> tab4(new SessionTab());
+  std::unique_ptr<SessionTab> tab4(new SessionTab());
   tab4->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
@@ -170,17 +171,17 @@ TEST_F(SessionsPageRevisitObserverTest, RunMatchersMany) {
           kDifferentUrl, ""));
   tab4->current_navigation_index = 1;
 
-  scoped_ptr<SessionWindow> window1(new SessionWindow());
+  std::unique_ptr<SessionWindow> window1(new SessionWindow());
   window1->tabs.push_back(tab1.release());
-  scoped_ptr<SessionWindow> window2(new SessionWindow());
+  std::unique_ptr<SessionWindow> window2(new SessionWindow());
   window2->tabs.push_back(tab2.release());
-  scoped_ptr<SessionWindow> window3(new SessionWindow());
+  std::unique_ptr<SessionWindow> window3(new SessionWindow());
   window3->tabs.push_back(tab3.release());
   window3->tabs.push_back(tab4.release());
 
-  scoped_ptr<SyncedSession> session1(new SyncedSession());
+  std::unique_ptr<SyncedSession> session1(new SyncedSession());
   session1->windows[1] = window1.release();
-  scoped_ptr<SyncedSession> session2(new SyncedSession());
+  std::unique_ptr<SyncedSession> session2(new SyncedSession());
   session2->windows[2] = window2.release();
   session2->windows[3] = window3.release();
 
@@ -188,7 +189,7 @@ TEST_F(SessionsPageRevisitObserverTest, RunMatchersMany) {
   sessions.push_back(session1.get());
   sessions.push_back(session2.get());
   SessionsPageRevisitObserver observer(
-      make_scoped_ptr(new TestForeignSessionsProvider(sessions, true)));
+      base::WrapUnique(new TestForeignSessionsProvider(sessions, true)));
 
   base::HistogramTester histogram_tester;
   CheckAndExpect(&observer, GURL(kExampleUrl), true, true);
diff --git a/components/sync_sessions/revisit/typed_url_page_revisit_observer.cc b/components/sync_sessions/revisit/typed_url_page_revisit_observer.cc
index 159189577cee28..747910b4871e7d 100644
--- a/components/sync_sessions/revisit/typed_url_page_revisit_observer.cc
+++ b/components/sync_sessions/revisit/typed_url_page_revisit_observer.cc
@@ -4,7 +4,7 @@
 
 #include "components/sync_sessions/revisit/typed_url_page_revisit_observer.h"
 
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/sync_sessions/revisit/typed_url_page_revisit_task.h"
 #include "url/gurl.h"
@@ -21,9 +21,9 @@ void TypedUrlPageRevisitObserver::OnPageVisit(
     const GURL& url,
     const PageVisitObserver::TransitionType transition) {
   if (history_) {
-    history_->ScheduleDBTask(scoped_ptr<history::HistoryDBTask>(
-                                 new TypedUrlPageRevisitTask(url, transition)),
-                             &task_tracker_);
+    history_->ScheduleDBTask(
+        base::WrapUnique(new TypedUrlPageRevisitTask(url, transition)),
+        &task_tracker_);
   }
 }
 
diff --git a/components/sync_sessions/session_data_type_controller.h b/components/sync_sessions/session_data_type_controller.h
index 07099824c5c5e1..601501bc7c120f 100644
--- a/components/sync_sessions/session_data_type_controller.h
+++ b/components/sync_sessions/session_data_type_controller.h
@@ -5,8 +5,9 @@
 #ifndef COMPONENTS_SYNC_SESSIONS_SESSION_DATA_TYPE_CONTROLLER_H_
 #define COMPONENTS_SYNC_SESSIONS_SESSION_DATA_TYPE_CONTROLLER_H_
 
+#include <memory>
+
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/sync_driver/local_device_info_provider.h"
 #include "components/sync_driver/ui_data_type_controller.h"
@@ -45,7 +46,8 @@ class SessionDataTypeController : public sync_driver::UIDataTypeController {
   sync_driver::SyncClient* const sync_client_;
 
   sync_driver::LocalDeviceInfoProvider* const local_device_;
-  scoped_ptr<sync_driver::LocalDeviceInfoProvider::Subscription> subscription_;
+  std::unique_ptr<sync_driver::LocalDeviceInfoProvider::Subscription>
+      subscription_;
 
   // Name of the pref that indicates whether saving history is disabled.
   const char* history_disabled_pref_name_;
diff --git a/components/sync_sessions/session_data_type_controller_unittest.cc b/components/sync_sessions/session_data_type_controller_unittest.cc
index c4974dd6c4e06c..0725ca85c95aeb 100644
--- a/components/sync_sessions/session_data_type_controller_unittest.cc
+++ b/components/sync_sessions/session_data_type_controller_unittest.cc
@@ -184,10 +184,10 @@ class SessionDataTypeControllerTest : public testing::Test,
   }
 
   scoped_refptr<SessionDataTypeController> controller_;
-  scoped_ptr<MockSyncedWindowDelegatesGetter> synced_window_getter_;
-  scoped_ptr<LocalDeviceInfoProviderMock> local_device_;
-  scoped_ptr<MockSyncedWindowDelegate> synced_window_delegate_;
-  scoped_ptr<TestSyncSessionsClient> sync_sessions_client_;
+  std::unique_ptr<MockSyncedWindowDelegatesGetter> synced_window_getter_;
+  std::unique_ptr<LocalDeviceInfoProviderMock> local_device_;
+  std::unique_ptr<MockSyncedWindowDelegate> synced_window_delegate_;
+  std::unique_ptr<TestSyncSessionsClient> sync_sessions_client_;
   bool load_finished_;
 
  private:
diff --git a/components/sync_sessions/sessions_sync_manager.cc b/components/sync_sessions/sessions_sync_manager.cc
index 96b6cc0423f0f1..a678c44f567745 100644
--- a/components/sync_sessions/sessions_sync_manager.cc
+++ b/components/sync_sessions/sessions_sync_manager.cc
@@ -80,7 +80,7 @@ SessionsSyncManager::SessionsSyncManager(
     sync_sessions::SyncSessionsClient* sessions_client,
     sync_driver::SyncPrefs* sync_prefs,
     LocalDeviceInfoProvider* local_device,
-    scoped_ptr<LocalSessionEventRouter> router,
+    std::unique_ptr<LocalSessionEventRouter> router,
     const base::Closure& sessions_updated_callback,
     const base::Closure& datatype_refresh_callback)
     : sessions_client_(sessions_client),
@@ -111,8 +111,8 @@ static std::string BuildMachineTag(const std::string& cache_guid) {
 syncer::SyncMergeResult SessionsSyncManager::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
-    scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
-    scoped_ptr<syncer::SyncErrorFactory> error_handler) {
+    std::unique_ptr<syncer::SyncChangeProcessor> sync_processor,
+    std::unique_ptr<syncer::SyncErrorFactory> error_handler) {
   syncer::SyncMergeResult merge_result(type);
   DCHECK(session_tracker_.Empty());
   DCHECK_EQ(0U, local_tab_pool_.Capacity());
@@ -364,8 +364,10 @@ void SessionsSyncManager::AssociateTab(SyncedTabDelegate* const tab,
 
 void SessionsSyncManager::RebuildAssociations() {
   syncer::SyncDataList data(sync_processor_->GetAllSyncData(syncer::SESSIONS));
-  scoped_ptr<syncer::SyncErrorFactory> error_handler(std::move(error_handler_));
-  scoped_ptr<syncer::SyncChangeProcessor> processor(std::move(sync_processor_));
+  std::unique_ptr<syncer::SyncErrorFactory> error_handler(
+      std::move(error_handler_));
+  std::unique_ptr<syncer::SyncChangeProcessor> processor(
+      std::move(sync_processor_));
 
   StopSyncing(syncer::SESSIONS);
   MergeDataAndStartSyncing(syncer::SESSIONS, data, std::move(processor),
diff --git a/components/sync_sessions/sessions_sync_manager.h b/components/sync_sessions/sessions_sync_manager.h
index 3617f577cfed69..952851ee4d2db1 100644
--- a/components/sync_sessions/sessions_sync_manager.h
+++ b/components/sync_sessions/sessions_sync_manager.h
@@ -8,6 +8,7 @@
 #include <stddef.h>
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
@@ -66,7 +67,7 @@ class SessionsSyncManager : public syncer::SyncableService,
   SessionsSyncManager(sync_sessions::SyncSessionsClient* sessions_client,
                       sync_driver::SyncPrefs* sync_prefs,
                       sync_driver::LocalDeviceInfoProvider* local_device,
-                      scoped_ptr<LocalSessionEventRouter> router,
+                      std::unique_ptr<LocalSessionEventRouter> router,
                       const base::Closure& sessions_updated_callback,
                       const base::Closure& datatype_refresh_callback);
   ~SessionsSyncManager() override;
@@ -75,8 +76,8 @@ class SessionsSyncManager : public syncer::SyncableService,
   syncer::SyncMergeResult MergeDataAndStartSyncing(
       syncer::ModelType type,
       const syncer::SyncDataList& initial_sync_data,
-      scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
-      scoped_ptr<syncer::SyncErrorFactory> error_handler) override;
+      std::unique_ptr<syncer::SyncChangeProcessor> sync_processor,
+      std::unique_ptr<syncer::SyncErrorFactory> error_handler) override;
   void StopSyncing(syncer::ModelType type) override;
   syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const override;
   syncer::SyncError ProcessSyncChanges(
@@ -345,8 +346,8 @@ class SessionsSyncManager : public syncer::SyncableService,
 
   sync_driver::SyncPrefs* sync_prefs_;
 
-  scoped_ptr<syncer::SyncErrorFactory> error_handler_;
-  scoped_ptr<syncer::SyncChangeProcessor> sync_processor_;
+  std::unique_ptr<syncer::SyncErrorFactory> error_handler_;
+  std::unique_ptr<syncer::SyncChangeProcessor> sync_processor_;
 
   // Local device info provider, owned by ProfileSyncService.
   const sync_driver::LocalDeviceInfoProvider* const local_device_;
@@ -365,7 +366,7 @@ class SessionsSyncManager : public syncer::SyncableService,
   // stale and a candidate for garbage collection.
   int stale_session_threshold_days_;
 
-  scoped_ptr<LocalSessionEventRouter> local_event_router_;
+  std::unique_ptr<LocalSessionEventRouter> local_event_router_;
 
   // Owns revisiting instrumentation logic for page visit events.
   PageRevisitBroadcaster page_revisit_broadcaster_;
diff --git a/components/sync_sessions/sync_sessions_client.h b/components/sync_sessions/sync_sessions_client.h
index 94cfebd92d8abe..9d53cd781aef5d 100644
--- a/components/sync_sessions/sync_sessions_client.h
+++ b/components/sync_sessions/sync_sessions_client.h
@@ -5,8 +5,9 @@
 #ifndef COMPONENTS_SYNC_SESSIONS_SYNC_SESSIONS_CLIENT_H_
 #define COMPONENTS_SYNC_SESSIONS_SYNC_SESSIONS_CLIENT_H_
 
+#include <memory>
+
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 
 class GURL;
 
@@ -54,7 +55,7 @@ class SyncSessionsClient {
 
   // Returns a LocalSessionEventRouter instance that is customized for the
   // embedder's context.
-  virtual scoped_ptr<browser_sync::LocalSessionEventRouter>
+  virtual std::unique_ptr<browser_sync::LocalSessionEventRouter>
   GetLocalSessionEventRouter() = 0;
 
   // TODO(zea): add getters for the history and favicon services for the favicon
diff --git a/components/sync_sessions/sync_sessions_metrics_unittest.cc b/components/sync_sessions/sync_sessions_metrics_unittest.cc
index 3b3cc71cfdf3b8..a016250dd72174 100644
--- a/components/sync_sessions/sync_sessions_metrics_unittest.cc
+++ b/components/sync_sessions/sync_sessions_metrics_unittest.cc
@@ -6,6 +6,7 @@
 
 #include <algorithm>
 
+#include "base/memory/ptr_util.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "components/sessions/core/session_types.h"
@@ -27,14 +28,13 @@ namespace {
 class FakeSessionsSyncManager : public browser_sync::SessionsSyncManager {
  public:
   FakeSessionsSyncManager(SyncSessionsClient* sessions_client,
-                          std::vector<scoped_ptr<SyncedSession>>* sessions)
-      : browser_sync::SessionsSyncManager(
-            sessions_client,
-            nullptr,
-            nullptr,
-            scoped_ptr<browser_sync::LocalSessionEventRouter>(),
-            base::Closure(),
-            base::Closure()),
+                          std::vector<std::unique_ptr<SyncedSession>>* sessions)
+      : browser_sync::SessionsSyncManager(sessions_client,
+                                          nullptr,
+                                          nullptr,
+                                          nullptr,
+                                          base::Closure(),
+                                          base::Closure()),
         sessions_(sessions) {}
 
   bool GetAllForeignSessions(
@@ -46,7 +46,7 @@ class FakeSessionsSyncManager : public browser_sync::SessionsSyncManager {
   }
 
  private:
-  std::vector<scoped_ptr<SyncedSession>>* sessions_;
+  std::vector<std::unique_ptr<SyncedSession>>* sessions_;
 };
 
 Time SecondsFromEpoch(int seconds) {
@@ -65,7 +65,7 @@ class SyncSessionsMetricsTest : public ::testing::Test {
   void PushTab(size_t tabIndex, int windowIndex, Time timestamp) {
     // First add sessions/windows as necessary.
     while (tabIndex >= sessions_.size()) {
-      sessions_.push_back(make_scoped_ptr(new SyncedSession()));
+      sessions_.push_back(base::WrapUnique(new SyncedSession()));
     }
     if (sessions_[tabIndex]->windows.find(windowIndex) ==
         sessions_[tabIndex]->windows.end()) {
@@ -107,7 +107,7 @@ class SyncSessionsMetricsTest : public ::testing::Test {
   }
 
  private:
-  std::vector<scoped_ptr<SyncedSession>> sessions_;
+  std::vector<std::unique_ptr<SyncedSession>> sessions_;
   FakeSyncSessionsClient fake_client_;
   FakeSessionsSyncManager fake_manager_;
 };
diff --git a/components/sync_sessions/synced_session_tracker_unittest.cc b/components/sync_sessions/synced_session_tracker_unittest.cc
index 0b3c034ce16e44..25dddb842cb23b 100644
--- a/components/sync_sessions/synced_session_tracker_unittest.cc
+++ b/components/sync_sessions/synced_session_tracker_unittest.cc
@@ -2,17 +2,17 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "components/sync_sessions/synced_session_tracker.h"
+
 #include <string>
 #include <vector>
 
-#include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/sessions/core/serialized_navigation_entry_test_helper.h"
 #include "components/sessions/core/session_types.h"
 #include "components/sync_sessions/fake_sync_sessions_client.h"
-#include "components/sync_sessions/synced_session_tracker.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace browser_sync {
diff --git a/components/sync_sessions/synced_tab_delegate.h b/components/sync_sessions/synced_tab_delegate.h
index 2745842fc4085b..def7256dd32939 100644
--- a/components/sync_sessions/synced_tab_delegate.h
+++ b/components/sync_sessions/synced_tab_delegate.h
@@ -8,7 +8,6 @@
 #include <string>
 #include <vector>
 
-#include "base/memory/scoped_ptr.h"
 #include "components/sessions/core/serialized_navigation_entry.h"
 #include "components/sessions/core/session_id.h"
 #include "ui/base/page_transition_types.h"