Convert //chrome/browser/sync from scoped_ptr to std::unique_ptr

chrome/browser/sync/sessions/sessions_sync_manager_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/sync_sessions/sessions_sync_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 243 matching lines @@
   base::FieldTrialList::FindFullName(trial_name);
 }
 
 class DummyRouter : public LocalSessionEventRouter {
  public:
   ~DummyRouter() override {}
   void StartRoutingTo(LocalSessionEventHandler* handler) override {}
   void Stop() override {}
 };
 
-scoped_ptr<LocalSessionEventRouter> NewDummyRouter() {
-  return scoped_ptr<LocalSessionEventRouter>(new DummyRouter());
+std::unique_ptr<LocalSessionEventRouter> NewDummyRouter() {
+  return std::unique_ptr<LocalSessionEventRouter>(new DummyRouter());
 }
 
 // Provides ability to override SyncedWindowDelegatesGetter.
 // All other calls are passed through to the original SyncSessionsClient.
 class SyncSessionsClientShim : public sync_sessions::SyncSessionsClient {
  public:
   SyncSessionsClientShim(
       sync_sessions::SyncSessionsClient* sync_sessions_client)
       : sync_sessions_client_(sync_sessions_client),
         synced_window_getter_(nullptr) {}
@@ skipping 19 matching lines @@
       override {
     // The idea here is to allow the test code override the default
     // SyncedWindowDelegatesGetter provided by |sync_sessions_client_|.
     // If |synced_window_getter_| is explicitly set, return it; otherwise return
     // the default one provided by |sync_sessions_client_|.
     return synced_window_getter_
                ? synced_window_getter_
                : sync_sessions_client_->GetSyncedWindowDelegatesGetter();
   }
 
-  scoped_ptr<browser_sync::LocalSessionEventRouter> GetLocalSessionEventRouter()
-      override {
+  std::unique_ptr<browser_sync::LocalSessionEventRouter>
+  GetLocalSessionEventRouter() override {
     return sync_sessions_client_->GetLocalSessionEventRouter();
   }
 
   void set_synced_window_getter(
       browser_sync::SyncedWindowDelegatesGetter* synced_window_getter) {
     synced_window_getter_ = synced_window_getter;
   }
 
  private:
   sync_sessions::SyncSessionsClient* const sync_sessions_client_;
@@ skipping 21 matching lines @@
     sync_client_.reset(new browser_sync::ChromeSyncClient(profile()));
     sessions_client_shim_.reset(
         new SyncSessionsClientShim(sync_client_->GetSyncSessionsClient()));
     browser_sync::NotificationServiceSessionsRouter* router(
         new browser_sync::NotificationServiceSessionsRouter(
             profile(), GetSyncSessionsClient(),
             syncer::SyncableService::StartSyncFlare()));
     sync_prefs_.reset(new sync_driver::SyncPrefs(profile()->GetPrefs()));
     manager_.reset(new SessionsSyncManager(
         GetSyncSessionsClient(), sync_prefs_.get(), local_device_.get(),
-        scoped_ptr<LocalSessionEventRouter>(router),
+        std::unique_ptr<LocalSessionEventRouter>(router),
         base::Bind(&SessionNotificationObserver::NotifyOfUpdate,
                    base::Unretained(&observer_)),
         base::Bind(&SessionNotificationObserver::NotifyOfRefresh,
                    base::Unretained(&observer_))));
   }
 
   void TearDown() override {
     test_processor_ = NULL;
     helper()->Reset();
     sync_prefs_.reset();
     manager_.reset();
     BrowserWithTestWindowTest::TearDown();
   }
 
   const DeviceInfo* GetLocalDeviceInfo() {
     return local_device_->GetLocalDeviceInfo();
   }
 
   SessionsSyncManager* manager() { return manager_.get(); }
   SessionSyncTestHelper* helper() { return &helper_; }
   LocalDeviceInfoProvider* local_device() { return local_device_.get(); }
   SessionNotificationObserver* observer() { return &observer_; }
 
   void InitWithSyncDataTakeOutput(const syncer::SyncDataList& initial_data,
                                   syncer::SyncChangeList* output) {
     test_processor_ = new TestSyncProcessorStub(output);
     syncer::SyncMergeResult result = manager_->MergeDataAndStartSyncing(
         syncer::SESSIONS, initial_data,
-        scoped_ptr<syncer::SyncChangeProcessor>(test_processor_),
-        scoped_ptr<syncer::SyncErrorFactory>(
+        std::unique_ptr<syncer::SyncChangeProcessor>(test_processor_),
+        std::unique_ptr<syncer::SyncErrorFactory>(
             new syncer::SyncErrorFactoryMock()));
     EXPECT_FALSE(result.error().IsSet());
   }
 
   void InitWithNoSyncData() {
     InitWithSyncDataTakeOutput(syncer::SyncDataList(), NULL);
   }
 
   void TriggerProcessSyncChangesError() {
     test_processor_->FailProcessSyncChangesWith(syncer::SyncError(
@@ skipping 29 matching lines @@
   }
 
   sync_driver::SyncPrefs* sync_prefs() { return sync_prefs_.get(); }
 
   void set_synced_window_getter(
       browser_sync::SyncedWindowDelegatesGetter* synced_window_getter) {
     sessions_client_shim_->set_synced_window_getter(synced_window_getter);
   }
 
  private:
-  scoped_ptr<browser_sync::ChromeSyncClient> sync_client_;
-  scoped_ptr<SyncSessionsClientShim> sessions_client_shim_;
-  scoped_ptr<sync_driver::SyncPrefs> sync_prefs_;
+  std::unique_ptr<browser_sync::ChromeSyncClient> sync_client_;
+  std::unique_ptr<SyncSessionsClientShim> sessions_client_shim_;
+  std::unique_ptr<sync_driver::SyncPrefs> sync_prefs_;
   SessionNotificationObserver observer_;
-  scoped_ptr<SessionsSyncManager> manager_;
+  std::unique_ptr<SessionsSyncManager> manager_;
   SessionSyncTestHelper helper_;
   TestSyncProcessorStub* test_processor_;
-  scoped_ptr<LocalDeviceInfoProviderMock> local_device_;
+  std::unique_ptr<LocalDeviceInfoProviderMock> local_device_;
 };
 
 // Test that the SyncSessionManager can properly fill in a SessionHeader.
 TEST_F(SessionsSyncManagerTest, PopulateSessionHeader) {
   sync_pb::SessionHeader header_s;
   header_s.set_client_name("Client 1");
   header_s.set_device_type(sync_pb::SyncEnums_DeviceType_TYPE_WIN);
 
   SyncedSession session;
   base::Time time = base::Time::Now();
@@ skipping 35 matching lines @@
   bool IsInitialBlankNavigation() const override {
     // This differs from NavigationControllerImpl, which has an initial blank
     // NavigationEntry.
     return GetEntryCount() == 0;
   }
   int GetCurrentEntryIndex() const override { return current_entry_index_; }
   void set_current_entry_index(int i) {
     current_entry_index_ = i;
   }
 
-  void AppendEntry(scoped_ptr<content::NavigationEntry> entry) {
+  void AppendEntry(std::unique_ptr<content::NavigationEntry> entry) {
     entries_.push_back(std::move(entry));
   }
 
   GURL GetVirtualURLAtIndex(int i) const override {
     if (static_cast<size_t>(i) >= entries_.size())
       return GURL();
     return entries_[i]->GetVirtualURL();
   }
 
   GURL GetFaviconURLAtIndex(int i) const override { return GURL(); }
@@ skipping 28 matching lines @@
   std::string GetExtensionAppId() const override { return std::string(); }
   bool ProfileIsSupervised() const override { return is_supervised_; }
   void set_is_supervised(bool is_supervised) { is_supervised_ = is_supervised; }
   const std::vector<const sessions::SerializedNavigationEntry*>*
   GetBlockedNavigations() const override {
     return &blocked_navigations_.get();
   }
   void set_blocked_navigations(
       std::vector<const content::NavigationEntry*>* navs) {
     for (auto* entry : *navs) {
-      scoped_ptr<sessions::SerializedNavigationEntry> serialized_entry(
+      std::unique_ptr<sessions::SerializedNavigationEntry> serialized_entry(
           new sessions::SerializedNavigationEntry());
       *serialized_entry =
           sessions::ContentSerializedNavigationBuilder::FromNavigationEntry(
               blocked_navigations_.size(), *entry);
       blocked_navigations_.push_back(serialized_entry.release());
     }
   }
   bool IsPlaceholderTab() const override { return true; }
 
   // Session sync related methods.
@@ skipping 30 matching lines @@
 static const base::Time kTime7 = base::Time::FromInternalValue(170);
 static const base::Time kTime8 = base::Time::FromInternalValue(180);
 static const base::Time kTime9 = base::Time::FromInternalValue(190);
 
 // Populate the mock tab delegate with some data and navigation
 // entries and make sure that setting a SessionTab from it preserves
 // those entries (and clobbers any existing data).
 TEST_F(SessionsSyncManagerTest, SetSessionTabFromDelegate) {
   // Create a tab with three valid entries.
   SyncedTabDelegateFake tab;
-  scoped_ptr<content::NavigationEntry> entry1(
+  std::unique_ptr<content::NavigationEntry> entry1(
       content::NavigationEntry::Create());
   GURL url1("http://www.google.com/");
   entry1->SetVirtualURL(url1);
   entry1->SetTimestamp(kTime1);
   entry1->SetHttpStatusCode(200);
-  scoped_ptr<content::NavigationEntry> entry2(
+  std::unique_ptr<content::NavigationEntry> entry2(
       content::NavigationEntry::Create());
   GURL url2("http://www.noodle.com/");
   entry2->SetVirtualURL(url2);
   entry2->SetTimestamp(kTime2);
   entry2->SetHttpStatusCode(201);
-  scoped_ptr<content::NavigationEntry> entry3(
+  std::unique_ptr<content::NavigationEntry> entry3(
       content::NavigationEntry::Create());
   GURL url3("http://www.doodle.com/");
   entry3->SetVirtualURL(url3);
   entry3->SetTimestamp(kTime3);
   entry3->SetHttpStatusCode(202);
 
   tab.AppendEntry(std::move(entry1));
   tab.AppendEntry(std::move(entry2));
   tab.AppendEntry(std::move(entry3));
   tab.set_current_entry_index(2);
@@ skipping 37 matching lines @@
             session_tab.navigations[1].blocked_state());
   EXPECT_EQ(SerializedNavigationEntry::STATE_INVALID,
             session_tab.navigations[2].blocked_state());
   EXPECT_TRUE(session_tab.session_storage_persistent_id.empty());
 }
 
 // Ensure the current_navigation_index gets set properly when the navigation
 // stack gets trucated to +/- 6 entries.
 TEST_F(SessionsSyncManagerTest, SetSessionTabFromDelegateNavigationIndex) {
   SyncedTabDelegateFake tab;
-  scoped_ptr<content::NavigationEntry> entry0(
+  std::unique_ptr<content::NavigationEntry> entry0(
       content::NavigationEntry::Create());
   GURL url0("http://www.google.com/");
   entry0->SetVirtualURL(url0);
   entry0->SetTimestamp(kTime0);
   entry0->SetHttpStatusCode(200);
-  scoped_ptr<content::NavigationEntry> entry1(
+  std::unique_ptr<content::NavigationEntry> entry1(
       content::NavigationEntry::Create());
   GURL url1("http://www.zoogle.com/");
   entry1->SetVirtualURL(url1);
   entry1->SetTimestamp(kTime1);
   entry1->SetHttpStatusCode(200);
-  scoped_ptr<content::NavigationEntry> entry2(
+  std::unique_ptr<content::NavigationEntry> entry2(
       content::NavigationEntry::Create());
   GURL url2("http://www.noogle.com/");
   entry2->SetVirtualURL(url2);
   entry2->SetTimestamp(kTime2);
   entry2->SetHttpStatusCode(200);
-  scoped_ptr<content::NavigationEntry> entry3(
+  std::unique_ptr<content::NavigationEntry> entry3(
       content::NavigationEntry::Create());
   GURL url3("http://www.doogle.com/");
   entry3->SetVirtualURL(url3);
   entry3->SetTimestamp(kTime3);
   entry3->SetHttpStatusCode(200);
-  scoped_ptr<content::NavigationEntry> entry4(
+  std::unique_ptr<content::NavigationEntry> entry4(
       content::NavigationEntry::Create());
   GURL url4("http://www.yoogle.com/");
   entry4->SetVirtualURL(url4);
   entry4->SetTimestamp(kTime4);
   entry4->SetHttpStatusCode(200);
-  scoped_ptr<content::NavigationEntry> entry5(
+  std::unique_ptr<content::NavigationEntry> entry5(
       content::NavigationEntry::Create());
   GURL url5("http://www.foogle.com/");
   entry5->SetVirtualURL(url5);
   entry5->SetTimestamp(kTime5);
   entry5->SetHttpStatusCode(200);
-  scoped_ptr<content::NavigationEntry> entry6(
+  std::unique_ptr<content::NavigationEntry> entry6(
       content::NavigationEntry::Create());
   GURL url6("http://www.boogle.com/");
   entry6->SetVirtualURL(url6);
   entry6->SetTimestamp(kTime6);
   entry6->SetHttpStatusCode(200);
-  scoped_ptr<content::NavigationEntry> entry7(
+  std::unique_ptr<content::NavigationEntry> entry7(
       content::NavigationEntry::Create());
   GURL url7("http://www.moogle.com/");
   entry7->SetVirtualURL(url7);
   entry7->SetTimestamp(kTime7);
   entry7->SetHttpStatusCode(200);
-  scoped_ptr<content::NavigationEntry> entry8(
+  std::unique_ptr<content::NavigationEntry> entry8(
       content::NavigationEntry::Create());
   GURL url8("http://www.poogle.com/");
   entry8->SetVirtualURL(url8);
   entry8->SetTimestamp(kTime8);
   entry8->SetHttpStatusCode(200);
-  scoped_ptr<content::NavigationEntry> entry9(
+  std::unique_ptr<content::NavigationEntry> entry9(
       content::NavigationEntry::Create());
   GURL url9("http://www.roogle.com/");
   entry9->SetVirtualURL(url9);
   entry9->SetTimestamp(kTime9);
   entry9->SetHttpStatusCode(200);
 
   tab.AppendEntry(std::move(entry0));
   tab.AppendEntry(std::move(entry1));
   tab.AppendEntry(std::move(entry2));
   tab.AppendEntry(std::move(entry3));
@@ skipping 12 matching lines @@
   ASSERT_EQ(8u, session_tab.navigations.size());
   EXPECT_EQ(url2, session_tab.navigations[0].virtual_url());
   EXPECT_EQ(url3, session_tab.navigations[1].virtual_url());
   EXPECT_EQ(url4, session_tab.navigations[2].virtual_url());
 }
 
 // Ensure the current_navigation_index gets set to the end of the navigation
 // stack if the current navigation is invalid.
 TEST_F(SessionsSyncManagerTest, SetSessionTabFromDelegateCurrentInvalid) {
   SyncedTabDelegateFake tab;
-  scoped_ptr<content::NavigationEntry> entry0(
+  std::unique_ptr<content::NavigationEntry> entry0(
       content::NavigationEntry::Create());
   entry0->SetVirtualURL(GURL("http://www.google.com"));
   entry0->SetTimestamp(kTime0);
   entry0->SetHttpStatusCode(200);
-  scoped_ptr<content::NavigationEntry> entry1(
+  std::unique_ptr<content::NavigationEntry> entry1(
       content::NavigationEntry::Create());
   entry1->SetVirtualURL(GURL(""));
   entry1->SetTimestamp(kTime1);
   entry1->SetHttpStatusCode(200);
-  scoped_ptr<content::NavigationEntry> entry2(
+  std::unique_ptr<content::NavigationEntry> entry2(
       content::NavigationEntry::Create());
   entry2->SetVirtualURL(GURL("http://www.noogle.com"));
   entry2->SetTimestamp(kTime2);
   entry2->SetHttpStatusCode(200);
-  scoped_ptr<content::NavigationEntry> entry3(
+  std::unique_ptr<content::NavigationEntry> entry3(
       content::NavigationEntry::Create());
   entry3->SetVirtualURL(GURL("http://www.doogle.com"));
   entry3->SetTimestamp(kTime3);
   entry3->SetHttpStatusCode(200);
 
   tab.AppendEntry(std::move(entry0));
   tab.AppendEntry(std::move(entry1));
   tab.AppendEntry(std::move(entry2));
   tab.AppendEntry(std::move(entry3));
   tab.set_current_entry_index(1);
@@ skipping 26 matching lines @@
 
   ASSERT_EQ(2u, session_tab.variation_ids.size());
   EXPECT_EQ(kVariationId1, session_tab.variation_ids[0]);
   EXPECT_EQ(kVariationId2, session_tab.variation_ids[1]);
 }
 
 // Tests that for supervised users blocked navigations are recorded and marked
 // as such, while regular navigations are marked as allowed.
 TEST_F(SessionsSyncManagerTest, BlockedNavigations) {
   SyncedTabDelegateFake tab;
-  scoped_ptr<content::NavigationEntry> entry1(
+  std::unique_ptr<content::NavigationEntry> entry1(
       content::NavigationEntry::Create());
   GURL url1("http://www.google.com/");
   entry1->SetVirtualURL(url1);
   entry1->SetTimestamp(kTime1);
   tab.AppendEntry(std::move(entry1));
 
-  scoped_ptr<content::NavigationEntry> entry2(
+  std::unique_ptr<content::NavigationEntry> entry2(
       content::NavigationEntry::Create());
   GURL url2("http://blocked.com/foo");
   entry2->SetVirtualURL(url2);
   entry2->SetTimestamp(kTime2);
-  scoped_ptr<content::NavigationEntry> entry3(
+  std::unique_ptr<content::NavigationEntry> entry3(
       content::NavigationEntry::Create());
   GURL url3("http://evil.com/");
   entry3->SetVirtualURL(url3);
   entry3->SetTimestamp(kTime3);
   ScopedVector<const content::NavigationEntry> blocked_navigations;
   blocked_navigations.push_back(std::move(entry2));
   blocked_navigations.push_back(std::move(entry3));
 
   tab.set_is_supervised(true);
   tab.set_blocked_navigations(&blocked_navigations.get());
@@ skipping 75 matching lines @@
       data.GetSpecifics(),
       base::Time(),
       syncer::AttachmentIdList(),
       syncer::AttachmentServiceProxyForTest::Create()));
   syncer::SyncDataList in(&d, &d + 1);
   out.clear();
   SessionsSyncManager manager2(GetSyncSessionsClient(), sync_prefs(),
                                local_device(), NewDummyRouter(),
                                base::Closure(), base::Closure());
   syncer::SyncMergeResult result = manager2.MergeDataAndStartSyncing(
-      syncer::SESSIONS, in,
-      scoped_ptr<syncer::SyncChangeProcessor>(
-          new TestSyncProcessorStub(&out)),
-      scoped_ptr<syncer::SyncErrorFactory>(
+      syncer::SESSIONS, in, std::unique_ptr<syncer::SyncChangeProcessor>(
+                                new TestSyncProcessorStub(&out)),
+      std::unique_ptr<syncer::SyncErrorFactory>(
           new syncer::SyncErrorFactoryMock()));
   ASSERT_FALSE(result.error().IsSet());
 
   EXPECT_EQ(1U, out.size());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, out[0].change_type());
   EXPECT_TRUE(out[0].sync_data().GetSpecifics().session().has_header());
 }
 
 // Ensure model association associates the pre-existing tabs.
 TEST_F(SessionsSyncManagerTest, SwappedOutOnRestore) {
@@ skipping 48 matching lines @@
   ASSERT_EQ(1U, windows.size());
   SyncedTabDelegateFake t1_override, t2_override;
   t1_override.SetSyncId(1);  // No WebContents by default.
   t2_override.SetSyncId(2);  // No WebContents by default.
   SyncedWindowDelegateOverride window_override(*windows.begin());
   window_override.OverrideTabAt(1, &t1_override, kNewTabId);
   window_override.OverrideTabAt(2, &t2_override,
                                 t2.GetSpecifics().session().tab().tab_id());
   std::set<const SyncedWindowDelegate*> delegates;
   delegates.insert(&window_override);
-  scoped_ptr<TestSyncedWindowDelegatesGetter> getter(
+  std::unique_ptr<TestSyncedWindowDelegatesGetter> getter(
       new TestSyncedWindowDelegatesGetter(delegates));
   set_synced_window_getter(getter.get());
 
   syncer::SyncMergeResult result = manager()->MergeDataAndStartSyncing(
-      syncer::SESSIONS, in,
-      scoped_ptr<syncer::SyncChangeProcessor>(
-          new TestSyncProcessorStub(&out)),
-      scoped_ptr<syncer::SyncErrorFactory>(
+      syncer::SESSIONS, in, std::unique_ptr<syncer::SyncChangeProcessor>(
+                                new TestSyncProcessorStub(&out)),
+      std::unique_ptr<syncer::SyncErrorFactory>(
           new syncer::SyncErrorFactoryMock()));
 
   // There should be two changes, one for the fully associated tab, and
   // one for the tab_id update to t1.  t2 shouldn't need to be updated.
   ASSERT_EQ(2U, FilterOutLocalHeaderChanges(&out)->size());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, out[0].change_type());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, out[1].change_type());
   EXPECT_EQ(kNewTabId,
             out[1].sync_data().GetSpecifics().session().tab().tab_id());
 
@@ skipping 490 matching lines @@
       entity,
       base::Time(),
       syncer::AttachmentIdList(),
       syncer::AttachmentServiceProxyForTest::Create()));
   syncer::SyncDataList in(&d, &d + 1);
   changes.clear();
   SessionsSyncManager manager2(GetSyncSessionsClient(), sync_prefs(),
                                local_device(), NewDummyRouter(),
                                base::Closure(), base::Closure());
   syncer::SyncMergeResult result = manager2.MergeDataAndStartSyncing(
-      syncer::SESSIONS, in,
-      scoped_ptr<syncer::SyncChangeProcessor>(
-          new TestSyncProcessorStub(&changes)),
-      scoped_ptr<syncer::SyncErrorFactory>(
+      syncer::SESSIONS, in, std::unique_ptr<syncer::SyncChangeProcessor>(
+                                new TestSyncProcessorStub(&changes)),
+      std::unique_ptr<syncer::SyncErrorFactory>(
           new syncer::SyncErrorFactoryMock()));
   ASSERT_FALSE(result.error().IsSet());
   EXPECT_TRUE(FilterOutLocalHeaderChanges(&changes)->empty());
 }
 
 TEST_F(SessionsSyncManagerTest, MergeDeletesCorruptNode) {
   syncer::SyncChangeList changes;
   InitWithNoSyncData();
 
   std::string local_tag = manager()->current_machine_tag();
@@ skipping 432 matching lines @@
 TEST_F(SessionsSyncManagerTest, CheckPrerenderedWebContentsSwap) {
   AddTab(browser(), GURL("http://foo1"));
   NavigateAndCommitActiveTab(GURL("http://foo2"));
 
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   ASSERT_EQ(4U, out.size());  // Header, tab ADD, tab UPDATE, header UPDATE.
 
   // To simulate WebContents swap during prerendering, create new WebContents
   // and swap with old WebContents.
-  scoped_ptr<content::WebContents> old_web_contents;
+  std::unique_ptr<content::WebContents> old_web_contents;
   old_web_contents.reset(browser()->tab_strip_model()->GetActiveWebContents());
 
   // Create new WebContents, with the required tab helpers.
   WebContents* new_web_contents = WebContents::CreateWithSessionStorage(
       WebContents::CreateParams(profile()),
       old_web_contents->GetController().GetSessionStorageNamespaceMap());
   SessionTabHelper::CreateForWebContents(new_web_contents);
   TabContentsSyncedTabDelegate::CreateForWebContents(new_web_contents);
   new_web_contents->GetController()
       .CopyStateFrom(old_web_contents->GetController());
@@ skipping 340 matching lines @@
   base::Time last_time;
   for (size_t i = 0; i < tabs.size(); ++i) {
     base::Time this_time = tabs[i]->timestamp;
     if (i > 0)
       ASSERT_GE(last_time, this_time);
     last_time = tabs[i]->timestamp;
   }
 }
 
 }  // namespace browser_sync