Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/background_sync/background_sync_manager_unittest.cc

 // Copyright 2015 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 "content/browser/background_sync/background_sync_manager.h"
 
 #include <stdint.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/mock_entropy_provider.h"
 #include "base/test/simple_test_clock.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/background_sync/background_sync_network_observer.h"
 #include "content/browser/background_sync/background_sync_status.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
@@ skipping 91 matching lines @@
 
   void SetUp() override {
     // Don't let the tests be confused by the real-world device connectivity
     background_sync_test_util::SetIgnoreNetworkChangeNotifier(true);
 
     // TODO(jkarlin): Create a new object with all of the necessary SW calls
     // so that we can inject test versions instead of bringing up all of this
     // extra SW stuff.
     helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath()));
 
-    scoped_ptr<MockPermissionManager> mock_permission_manager(
+    std::unique_ptr<MockPermissionManager> mock_permission_manager(
         new testing::NiceMock<MockPermissionManager>());
     ON_CALL(*mock_permission_manager,
             GetPermissionStatus(PermissionType::BACKGROUND_SYNC, _, _))
         .WillByDefault(Return(blink::mojom::PermissionStatus::GRANTED));
     helper_->browser_context()->SetPermissionManager(
         std::move(mock_permission_manager));
 
     // Create a StoragePartition with the correct BrowserContext so that the
     // BackgroundSyncManager can find the BrowserContext through it.
     storage_partition_impl_.reset(new StoragePartitionImpl(
@@ skipping 54 matching lines @@
           test_background_sync_manager_->GetNetworkObserverForTesting();
       network_observer->NotifyManagerIfNetworkChangedForTesting(
           connection_type);
       base::RunLoop().RunUntilIdle();
     }
   }
 
   void StatusAndRegistrationCallback(
       bool* was_called,
       BackgroundSyncStatus status,
-      scoped_ptr<BackgroundSyncRegistration> registration) {
+      std::unique_ptr<BackgroundSyncRegistration> registration) {
     *was_called = true;
     callback_status_ = status;
     callback_registration_ = std::move(registration);
   }
 
   void StatusAndRegistrationsCallback(
       bool* was_called,
       BackgroundSyncStatus status,
-      scoped_ptr<ScopedVector<BackgroundSyncRegistration>> registrations) {
+      std::unique_ptr<ScopedVector<BackgroundSyncRegistration>> registrations) {
     *was_called = true;
     callback_status_ = status;
     callback_registrations_ = std::move(registrations);
   }
 
   void StatusCallback(bool* was_called, BackgroundSyncStatus status) {
     *was_called = true;
     callback_status_ = status;
   }
 
  protected:
   void CreateBackgroundSyncManager() {
     test_background_sync_manager_ =
         new TestBackgroundSyncManager(helper_->context_wrapper());
     background_sync_manager_.reset(test_background_sync_manager_);
 
     test_clock_ = new base::SimpleTestClock();
-    background_sync_manager_->set_clock(make_scoped_ptr(test_clock_));
+    background_sync_manager_->set_clock(base::WrapUnique(test_clock_));
 
     // Many tests do not expect the sync event to fire immediately after
     // register (and cleanup up the sync registrations).  Tests can control when
     // the sync event fires by manipulating the network state as needed.
     // NOTE: The setup of the network connection must happen after the
     //       BackgroundSyncManager has been created.
     SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
   }
 
   void InitBackgroundSyncManager() {
@@ skipping 161 matching lines @@
   void SetMaxSyncAttemptsAndRestartManager(int max_sync_attempts) {
     BackgroundSyncParameters* parameters =
         GetController()->background_sync_parameters();
     parameters->max_sync_attempts = max_sync_attempts;
 
     // Restart the BackgroundSyncManager so that it updates its parameters.
     SetupBackgroundSyncManager();
   }
 
   TestBrowserThreadBundle browser_thread_bundle_;
-  scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
-  scoped_ptr<EmbeddedWorkerTestHelper> helper_;
-  scoped_ptr<BackgroundSyncManager> background_sync_manager_;
-  scoped_ptr<StoragePartitionImpl> storage_partition_impl_;
+  std::unique_ptr<net::NetworkChangeNotifier> network_change_notifier_;
+  std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
+  std::unique_ptr<BackgroundSyncManager> background_sync_manager_;
+  std::unique_ptr<StoragePartitionImpl> storage_partition_impl_;
   TestBackgroundSyncManager* test_background_sync_manager_ = nullptr;
   base::SimpleTestClock* test_clock_ = nullptr;
 
   int64_t sw_registration_id_1_;
   int64_t sw_registration_id_2_;
   scoped_refptr<ServiceWorkerRegistration> sw_registration_1_;
   scoped_refptr<ServiceWorkerRegistration> sw_registration_2_;
 
   BackgroundSyncRegistrationOptions sync_options_1_;
   BackgroundSyncRegistrationOptions sync_options_2_;
 
   // Callback values.
   BackgroundSyncStatus callback_status_ = BACKGROUND_SYNC_STATUS_OK;
-  scoped_ptr<BackgroundSyncRegistration> callback_registration_;
-  scoped_ptr<ScopedVector<BackgroundSyncRegistration>> callback_registrations_;
+  std::unique_ptr<BackgroundSyncRegistration> callback_registration_;
+  std::unique_ptr<ScopedVector<BackgroundSyncRegistration>>
+      callback_registrations_;
   ServiceWorkerStatusCode callback_sw_status_code_ = SERVICE_WORKER_OK;
   int sync_events_called_ = 0;
   ServiceWorkerVersion::StatusCallback sync_fired_callback_;
 };
 
 TEST_F(BackgroundSyncManagerTest, Register) {
   EXPECT_TRUE(Register(sync_options_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, RegistrationIntact) {
@@ skipping 872 matching lines @@
   // Run it again.
   test_clock_->Advance(test_background_sync_manager_->delayed_task_delta());
   test_background_sync_manager_->delayed_task().Run();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(GetRegistration(sync_options_1_));
   EXPECT_EQ(mojom::BackgroundSyncEventLastChance::IS_LAST_CHANCE,
             test_background_sync_manager_->last_chance());
 }
 
 }  // namespace content