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

chrome/browser/safe_browsing/incident_reporting/off_domain_inclusion_detector_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/safe_browsing/incident_reporting/off_domain_inclusion_detector.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/history/chrome_history_client.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/web_history_service_factory.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 28 matching lines @@
 using testing::NiceMock;
 using testing::Return;
 using testing::Values;
 
 namespace {
 
 const int kFakeRenderProcessId = 123;
 
 // A BrowserContextKeyedServiceFactory::TestingFactoryFunction that creates a
 // HistoryService for a TestingProfile.
-scoped_ptr<KeyedService> BuildHistoryService(content::BrowserContext* context) {
+std::unique_ptr<KeyedService> BuildHistoryService(
+    content::BrowserContext* context) {
   TestingProfile* profile = static_cast<TestingProfile*>(context);
 
   // Delete the file before creating the service.
   base::FilePath history_path(
       profile->GetPath().Append(history::kHistoryFilename));
   if (!base::DeleteFile(history_path, false) ||
       base::PathExists(history_path)) {
     ADD_FAILURE() << "failed to delete history db file "
                   << history_path.value();
     return nullptr;
   }
 
-  scoped_ptr<history::HistoryService> history_service(
+  std::unique_ptr<history::HistoryService> history_service(
       new history::HistoryService(
-          make_scoped_ptr(new ChromeHistoryClient(
+          base::WrapUnique(new ChromeHistoryClient(
               BookmarkModelFactory::GetForProfile(profile))),
-          scoped_ptr<history::VisitDelegate>()));
+          std::unique_ptr<history::VisitDelegate>()));
   if (history_service->Init(
           history::HistoryDatabaseParamsForPath(profile->GetPath()))) {
     return std::move(history_service);
   }
 
   ADD_FAILURE() << "failed to initialize history service";
   return nullptr;
 }
 
 }  // namespace
@@ skipping 135 matching lines @@
   void SimulateTestURLRequest(const std::string& url_str,
                               const std::string& referrer,
                               content::ResourceType resource_type,
                               bool is_main_frame,
                               bool parent_is_main_frame) const {
     const GURL url(url_str);
 
     history::HistoryService* history_service =
         HistoryServiceFactory::GetForProfile(
             testing_profile_, ServiceAccessType::EXPLICIT_ACCESS);
-    scoped_ptr<ScopedHistoryEntry> scoped_history_entry;
+    std::unique_ptr<ScopedHistoryEntry> scoped_history_entry;
     if (ShouldAddSimulatedURLsToHistory())
       scoped_history_entry.reset(new ScopedHistoryEntry(history_service, url));
 
-    scoped_ptr<net::URLRequest> url_request(
+    std::unique_ptr<net::URLRequest> url_request(
         context_.CreateRequest(url, net::DEFAULT_PRIORITY, NULL));
 
     if (!referrer.empty())
       url_request->SetReferrer(referrer);
 
     content::ResourceRequestInfo::AllocateForTesting(
         url_request.get(),
         resource_type,
         NULL,                  // resource_context
         kFakeRenderProcessId,  // render_process_id
@@ skipping 73 matching lines @@
     TestingProfile::TestingFactories factories;
     factories.push_back(std::make_pair(HistoryServiceFactory::GetInstance(),
                                        &BuildHistoryService));
     // Suppress WebHistoryService since it makes network requests.
     factories.push_back(std::make_pair(
         WebHistoryServiceFactory::GetInstance(),
         static_cast<BrowserContextKeyedServiceFactory::TestingFactoryFunction>(
             NULL)));
 
     // Create default prefs for the test profile.
-    scoped_ptr<syncable_prefs::TestingPrefServiceSyncable> prefs(
+    std::unique_ptr<syncable_prefs::TestingPrefServiceSyncable> prefs(
         new syncable_prefs::TestingPrefServiceSyncable);
     chrome::RegisterUserProfilePrefs(prefs->registry());
 
     // |testing_profile_| is owned by |profile_manager_|.
     testing_profile_ = profile_manager_->CreateTestingProfile(
         "profile",  // profile_name
         std::move(prefs),
         base::UTF8ToUTF16("user"),  // user_name
         0,                          // avatar_id
         std::string(),              // supervised_user_id
@@ skipping 18 matching lines @@
                    base::Unretained(this))));
     // ProfileFromRenderProcessId doesn't *have* to be called, but if it is, it
     // should always request the profile for |kFakeRenderProcessId| and this
     // test will always return it |testing_profile_|.
     ON_CALL(*off_domain_inclusion_detector_,
             ProfileFromRenderProcessId(Eq(kFakeRenderProcessId)))
         .WillByDefault(Return(testing_profile_));
   }
 
   Profile* testing_profile_;
-  scoped_ptr<TestingProfileManager> profile_manager_;
+  std::unique_ptr<TestingProfileManager> profile_manager_;
 
   content::TestBrowserThreadBundle thread_bundle_;
   net::TestURLRequestContext context_;
 
   AnalysisEvent observed_analysis_event_;
 
-  scoped_ptr<MockOffDomainInclusionDetector> off_domain_inclusion_detector_;
+  std::unique_ptr<MockOffDomainInclusionDetector>
+      off_domain_inclusion_detector_;
 
   DISALLOW_COPY_AND_ASSIGN(OffDomainInclusionDetectorTest);
 };
 
 TEST_P(OffDomainInclusionDetectorTest, NoEventForIgnoredResourceTypes) {
   for (content::ResourceType tested_type : kResourceTypesIgnored) {
     SCOPED_TRACE(tested_type);
 
     SimulateTestURLRequest("http://offdomain.com/foo",
                            "http://mydomain.com/bar",
@@ skipping 207 matching lines @@
 }
 
 INSTANTIATE_TEST_CASE_P(OffDomainInclusionDetectorTestInstance,
                         OffDomainInclusionDetectorTest,
                         Values(TestCase::WHITELISTED,
                                TestCase::IN_HISTORY,
                                TestCase::IN_HISTORY_AND_WHITELISTED,
                                TestCase::UNKNOWN));
 
 }  // namespace safe_browsing