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

chrome/browser/supervised_user/supervised_user_service_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 "chrome/browser/supervised_user/supervised_user_service.h"
 
 #include <stddef.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/supervised_user/legacy/custodian_profile_downloader_service.h"
@@ skipping 60 matching lines @@
     quit_called_ = true;
     run_loop_->Quit();
   }
 
  private:
   void Reset() {
     quit_called_ = false;
     run_loop_.reset(new base::RunLoop);
   }
 
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
   bool quit_called_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncTestHelper);
 };
 
 class SupervisedUserURLFilterObserver
     : public AsyncTestHelper,
       public SupervisedUserURLFilter::Observer {
  public:
   SupervisedUserURLFilterObserver() : scoped_observer_(this) {}
@@ skipping 86 matching lines @@
   ~SupervisedUserServiceTest() override {}
 
  protected:
   void AddURLAccessRequest(const GURL& url, AsyncResultHolder* result_holder) {
     supervised_user_service_->AddURLAccessRequest(
         url, base::Bind(&AsyncResultHolder::SetResult,
                         base::Unretained(result_holder)));
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
-  scoped_ptr<TestingProfile> profile_;
+  std::unique_ptr<TestingProfile> profile_;
   SupervisedUserService* supervised_user_service_;
 };
 
 }  // namespace
 
 TEST_F(SupervisedUserServiceTest, ChangesIncludedSessionOnChangedSettings) {
   supervised_user_service_->Init();
   EXPECT_TRUE(supervised_user_service_->IncludesSyncSessionsType());
   profile_->GetPrefs()->SetBoolean(prefs::kRecordHistory, false);
   EXPECT_FALSE(supervised_user_service_->IncludesSyncSessionsType());
@@ skipping 69 matching lines @@
   EXPECT_FALSE(supervised_user_service_->AccessRequestsEnabled());
   {
     AsyncResultHolder result_holder;
     AddURLAccessRequest(url, &result_holder);
     EXPECT_FALSE(result_holder.GetResult());
   }
 
   // Add a disabled permission request creator. This should not change anything.
   MockPermissionRequestCreator* creator = new MockPermissionRequestCreator;
   supervised_user_service_->AddPermissionRequestCreator(
-      make_scoped_ptr(creator));
+      base::WrapUnique(creator));
 
   EXPECT_FALSE(supervised_user_service_->AccessRequestsEnabled());
   {
     AsyncResultHolder result_holder;
     AddURLAccessRequest(url, &result_holder);
     EXPECT_FALSE(result_holder.GetResult());
   }
 
   // Enable the permission request creator. This should enable permission
   // requests and queue them up.
@@ skipping 16 matching lines @@
     EXPECT_EQ(url.spec(), creator->requested_urls()[0].spec());
 
     creator->AnswerRequest(0, false);
     EXPECT_FALSE(result_holder.GetResult());
   }
 
   // Add a second permission request creator.
   MockPermissionRequestCreator* creator_2 = new MockPermissionRequestCreator;
   creator_2->set_enabled(true);
   supervised_user_service_->AddPermissionRequestCreator(
-      make_scoped_ptr(creator_2));
+      base::WrapUnique(creator_2));
 
   {
     AsyncResultHolder result_holder;
     AddURLAccessRequest(url, &result_holder);
     ASSERT_EQ(1u, creator->requested_urls().size());
     EXPECT_EQ(url.spec(), creator->requested_urls()[0].spec());
 
     // Make the first creator succeed. This should make the whole thing succeed.
     creator->AnswerRequest(0, true);
     EXPECT_TRUE(result_holder.GetResult());
@@ skipping 45 matching lines @@
     url_filter_observer_.Wait();
   }
 
   void TearDown() override {
     // Flush the message loop, to ensure all posted tasks run.
     base::RunLoop().RunUntilIdle();
   }
 
  protected:
   scoped_refptr<extensions::Extension> MakeThemeExtension() {
-    scoped_ptr<base::DictionaryValue> source(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> source(new base::DictionaryValue());
     source->SetString(extensions::manifest_keys::kName, "Theme");
     source->Set(extensions::manifest_keys::kTheme, new base::DictionaryValue());
     source->SetString(extensions::manifest_keys::kVersion, "1.0");
     extensions::ExtensionBuilder builder;
     scoped_refptr<extensions::Extension> extension =
         builder.SetManifest(std::move(source)).Build();
     return extension;
   }
 
   scoped_refptr<extensions::Extension> MakeExtension(bool by_custodian) {
-    scoped_ptr<base::DictionaryValue> manifest = extensions::DictionaryBuilder()
-      .Set(extensions::manifest_keys::kName, "Extension")
-      .Set(extensions::manifest_keys::kVersion, "1.0")
-      .Build();
+    std::unique_ptr<base::DictionaryValue> manifest =
+        extensions::DictionaryBuilder()
+            .Set(extensions::manifest_keys::kName, "Extension")
+            .Set(extensions::manifest_keys::kVersion, "1.0")
+            .Build();
     int creation_flags = extensions::Extension::NO_FLAGS;
     if (by_custodian)
       creation_flags |= extensions::Extension::WAS_INSTALLED_BY_CUSTODIAN;
     extensions::ExtensionBuilder builder;
     scoped_refptr<extensions::Extension> extension =
         builder.SetManifest(std::move(manifest))
             .AddFlags(creation_flags)
             .Build();
     return extension;
   }
@@ skipping 162 matching lines @@
   EXPECT_EQ(title2, site_list_observer_.site_lists()[0]->title());
   EXPECT_TRUE(site_list_observer_.site_lists()[0]->entry_point().is_empty());
 
   url_filter_observer_.Wait();
   EXPECT_EQ(SupervisedUserURLFilter::WARN,
             url_filter->GetFilteringBehaviorForURL(youtube_url));
   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
             url_filter->GetFilteringBehaviorForURL(moose_url));
 }
 #endif  // defined(ENABLE_EXTENSIONS)