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

chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc

 // Copyright (c) 2012 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.
 //
 // This test creates a safebrowsing service using test safebrowsing database
 // and a test protocol manager. It is used to test logics in safebrowsing
 // service.
 
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/field_trial.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/thread_test_helper.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
@@ skipping 71 matching lines @@
  public:
   ~NeverCompletingHttpResponse() override {}
 
   void SendResponse(
       const net::test_server::SendBytesCallback& send,
       const net::test_server::SendCompleteCallback& done) override {
     // Do nothing. |done| is never called.
   }
 };
 
-scoped_ptr<net::test_server::HttpResponse> HandleNeverCompletingRequests(
+std::unique_ptr<net::test_server::HttpResponse> HandleNeverCompletingRequests(
     const net::test_server::HttpRequest& request) {
   if (!base::StartsWith(request.relative_url, kNeverCompletesPath,
                           base::CompareCase::SENSITIVE))
     return nullptr;
-  return make_scoped_ptr(new NeverCompletingHttpResponse());
+  return base::WrapUnique(new NeverCompletingHttpResponse());
 }
 
 void InvokeFullHashCallback(
     SafeBrowsingProtocolManager::FullHashCallback callback,
     const std::vector<SBFullHashResult>& result) {
   callback.Run(result, base::TimeDelta::FromMinutes(45));
 }
 
 class FakeSafeBrowsingUIManager : public SafeBrowsingUIManager {
  public:
@@ skipping 143 matching lines @@
     prefix_hits->clear();
     return ContainsUrlPrefixes(RESOURCEBLACKLIST, RESOURCEBLACKLIST,
                                prefixes, prefix_hits);
   }
   bool UpdateStarted(std::vector<SBListChunkRanges>* lists) override {
     ADD_FAILURE() << "Not implemented.";
     return false;
   }
   void InsertChunks(
       const std::string& list_name,
-      const std::vector<scoped_ptr<SBChunkData>>& chunks) override {
+      const std::vector<std::unique_ptr<SBChunkData>>& chunks) override {
     ADD_FAILURE() << "Not implemented.";
   }
   void DeleteChunks(const std::vector<SBChunkDelete>& chunk_deletes) override {
     ADD_FAILURE() << "Not implemented.";
   }
   void UpdateFinished(bool update_succeeded) override {
     ADD_FAILURE() << "Not implemented.";
   }
   void CacheHashResults(const std::vector<SBPrefix>& prefixes,
                         const std::vector<SBFullHashResult>& cache_hits,
@@ skipping 380 matching lines @@
   // Waits for pending tasks on the IO thread to complete and check if the
   // SafeBrowsingService enabled state matches |enabled|.
   void WaitForIOAndCheckEnabled(SafeBrowsingService* service, bool enabled) {
     scoped_refptr<ServiceEnabledHelper> enabled_helper(new ServiceEnabledHelper(
         service, enabled,
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get()));
     ASSERT_TRUE(enabled_helper->Run());
   }
 
  private:
-  scoped_ptr<TestSafeBrowsingServiceFactory> sb_factory_;
+  std::unique_ptr<TestSafeBrowsingServiceFactory> sb_factory_;
   TestSafeBrowsingDatabaseFactory db_factory_;
   TestSBProtocolManagerFactory pm_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServiceTest);
 };
 
 class SafeBrowsingServiceMetadataTest
     : public SafeBrowsingServiceTest,
       public ::testing::WithParamInterface<ThreatPatternType> {
  public:
@@ skipping 750 matching lines @@
 
   EXPECT_TRUE(pref_service->GetBoolean(prefs::kSafeBrowsingEnabled));
 
   // SBS might still be starting, make sure this doesn't flake.
   EXPECT_TRUE(sb_service->enabled_by_prefs());
   WaitForIOAndCheckEnabled(sb_service, true);
   EXPECT_TRUE(csd_service->enabled());
 
   // Add a new Profile. SBS should keep running.
   ASSERT_TRUE(temp_profile_dir_.CreateUniqueTempDir());
-  scoped_ptr<Profile> profile2(Profile::CreateProfile(
+  std::unique_ptr<Profile> profile2(Profile::CreateProfile(
       temp_profile_dir_.path(), NULL, Profile::CREATE_MODE_SYNCHRONOUS));
   ASSERT_TRUE(profile2.get() != NULL);
   StartupTaskRunnerServiceFactory::GetForProfile(profile2.get())->
       StartDeferredTaskRunners();
   PrefService* pref_service2 = profile2->GetPrefs();
   EXPECT_TRUE(pref_service2->GetBoolean(prefs::kSafeBrowsingEnabled));
   // We don't expect the state to have changed, but if it did, wait for it.
   EXPECT_TRUE(sb_service->enabled_by_prefs());
   WaitForIOAndCheckEnabled(sb_service, true);
   EXPECT_TRUE(csd_service->enabled());
@@ skipping 207 matching lines @@
   void TearDownOnMainThread() override { sb_service_ = NULL; }
 
   void ForceUpdate() {
     sb_service_->protocol_manager()->ForceScheduleNextUpdate(
         base::TimeDelta::FromSeconds(0));
   }
 
   scoped_refptr<SafeBrowsingService> sb_service_;
 
  private:
-  static scoped_ptr<net::test_server::HttpResponse> HandleRequest(
+  static std::unique_ptr<net::test_server::HttpResponse> HandleRequest(
       const net::test_server::HttpRequest& request) {
     if (!base::StartsWith(request.relative_url, "/testpath/",
                           base::CompareCase::SENSITIVE)) {
       ADD_FAILURE() << "bad path";
       return nullptr;
     }
 
     auto cookie_it = request.headers.find("Cookie");
     if (cookie_it == request.headers.end()) {
       ADD_FAILURE() << "no cookie header";
       return nullptr;
     }
 
     net::cookie_util::ParsedRequestCookies req_cookies;
     net::cookie_util::ParseRequestCookieLine(cookie_it->second, &req_cookies);
     if (req_cookies.size() != 1) {
       ADD_FAILURE() << "req_cookies.size() = " << req_cookies.size();
       return nullptr;
     }
     const net::cookie_util::ParsedRequestCookie expected_cookie(
         std::make_pair("a", "b"));
     const net::cookie_util::ParsedRequestCookie& cookie = req_cookies.front();
     if (cookie != expected_cookie) {
       ADD_FAILURE() << "bad cookie " << cookie.first << "=" << cookie.second;
       return nullptr;
     }
 
-    scoped_ptr<net::test_server::BasicHttpResponse> http_response(
+    std::unique_ptr<net::test_server::BasicHttpResponse> http_response(
         new net::test_server::BasicHttpResponse());
     http_response->set_content("foo");
     http_response->set_content_type("text/plain");
     http_response->AddCustomHeader(
         "Set-Cookie", "c=d; Expires=Fri, 01 Jan 2038 01:01:01 GMT");
     return std::move(http_response);
   }
 
-  scoped_ptr<TestSafeBrowsingServiceFactory> sb_factory_;
+  std::unique_ptr<TestSafeBrowsingServiceFactory> sb_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingDatabaseManagerCookieTest);
 };
 
 // Test that a Local Safe Browsing database update request both sends cookies
 // and can save cookies.
 IN_PROC_BROWSER_TEST_F(SafeBrowsingDatabaseManagerCookieTest,
                        TestSBUpdateCookies) {
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
       content::Source<SafeBrowsingDatabaseManager>(
           sb_service_->database_manager().get()));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManagerCookieTest::ForceUpdate, this));
   observer.Wait();
 }
 
 }  // namespace safe_browsing