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

chrome/browser/safe_browsing/protocol_manager_unittest.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.
 
+#include "chrome/browser/safe_browsing/protocol_manager.h"
+
+#include <memory>
 #include <vector>
 
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/chunk.pb.h"
-#include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "components/safe_browsing_db/safebrowsing.pb.h"
 #include "components/safe_browsing_db/util.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 49 matching lines @@
 
   void SetUp() override {
     std::string key = google_apis::GetAPIKey();
     if (!key.empty()) {
       key_param_ = base::StringPrintf(
           "&key=%s",
           net::EscapeQueryParamValue(key, true).c_str());
     }
   }
 
-  scoped_ptr<SafeBrowsingProtocolManager> CreateProtocolManager(
+  std::unique_ptr<SafeBrowsingProtocolManager> CreateProtocolManager(
       SafeBrowsingProtocolManagerDelegate* delegate) {
     SafeBrowsingProtocolConfig config;
     config.client_name = kClient;
     config.url_prefix = kUrlPrefix;
     config.backup_connect_error_url_prefix = kBackupConnectUrlPrefix;
     config.backup_http_error_url_prefix = kBackupHttpUrlPrefix;
     config.backup_network_error_url_prefix = kBackupNetworkUrlPrefix;
     config.version = kAppVer;
-    return scoped_ptr<SafeBrowsingProtocolManager>(
+    return std::unique_ptr<SafeBrowsingProtocolManager>(
         SafeBrowsingProtocolManager::Create(delegate, NULL, config));
   }
 
   void ValidateUpdateFetcherRequest(const net::TestURLFetcher* url_fetcher,
                                     const std::string& expected_prefix,
                                     const std::string& expected_suffix) {
     ASSERT_TRUE(url_fetcher);
     EXPECT_EQ(net::LOAD_DISABLE_CACHE, url_fetcher->GetLoadFlags());
 
     std::string expected_lists(base::StringPrintf("%s;\n%s;\n",
@@ skipping 14 matching lines @@
                                       const std::string& expected_url) {
     ASSERT_TRUE(url_fetcher);
     EXPECT_EQ(net::LOAD_DISABLE_CACHE, url_fetcher->GetLoadFlags());
     EXPECT_EQ("", url_fetcher->upload_data());
     EXPECT_EQ(GURL(expected_url), url_fetcher->GetOriginalURL());
   }
 };
 
 // Ensure that we respect section 5 of the SafeBrowsing protocol specification.
 TEST_F(SafeBrowsingProtocolManagerTest, TestBackOffTimes) {
-  scoped_ptr<SafeBrowsingProtocolManager> pm(CreateProtocolManager(NULL));
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(CreateProtocolManager(NULL));
 
   pm->next_update_interval_ = TimeDelta::FromSeconds(1800);
   ASSERT_TRUE(pm->back_off_fuzz_ >= 0.0 && pm->back_off_fuzz_ <= 1.0);
 
   TimeDelta next;
 
   // No errors received so far.
   next = pm->GetNextUpdateInterval(false);
   EXPECT_EQ(next, TimeDelta::FromSeconds(1800));
 
@@ skipping 28 matching lines @@
   // 7 errors.
   next = pm->GetNextUpdateInterval(true);
   EXPECT_EQ(next, TimeDelta::FromMinutes(480));
 
   // Received a successful response.
   next = pm->GetNextUpdateInterval(false);
   EXPECT_EQ(next, TimeDelta::FromSeconds(1800));
 }
 
 TEST_F(SafeBrowsingProtocolManagerTest, TestChunkStrings) {
-  scoped_ptr<SafeBrowsingProtocolManager> pm(CreateProtocolManager(NULL));
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(CreateProtocolManager(NULL));
 
   // Add and Sub chunks.
   SBListChunkRanges phish(kDefaultPhishList);
   phish.adds = "1,4,6,8-20,99";
   phish.subs = "16,32,64-96";
   EXPECT_EQ(base::StringPrintf("%s;a:1,4,6,8-20,99:s:16,32,64-96\n",
                                kDefaultPhishList),
             FormatList(phish));
 
   // Add chunks only.
   phish.subs = "";
   EXPECT_EQ(base::StringPrintf("%s;a:1,4,6,8-20,99\n", kDefaultPhishList),
             FormatList(phish));
 
   // Sub chunks only.
   phish.adds = "";
   phish.subs = "16,32,64-96";
   EXPECT_EQ(base::StringPrintf("%s;s:16,32,64-96\n", kDefaultPhishList),
             FormatList(phish));
 
   // No chunks of either type.
   phish.adds = "";
   phish.subs = "";
   EXPECT_EQ(base::StringPrintf("%s;\n", kDefaultPhishList), FormatList(phish));
 }
 
 TEST_F(SafeBrowsingProtocolManagerTest, TestGetHashBackOffTimes) {
-  scoped_ptr<SafeBrowsingProtocolManager> pm(CreateProtocolManager(NULL));
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(CreateProtocolManager(NULL));
 
   // No errors or back off time yet.
   EXPECT_EQ(0U, pm->gethash_error_count_);
   EXPECT_TRUE(pm->next_gethash_time_.is_null());
 
   Time now = Time::Now();
 
   // 1 error.
   pm->HandleGetHashError(now);
   EXPECT_EQ(1U, pm->gethash_error_count_);
@@ skipping 31 matching lines @@
   EXPECT_EQ(6U, pm->gethash_error_count_);
   EXPECT_TRUE(pm->next_gethash_time_ == now + TimeDelta::FromMinutes(480));
 
   // 7 errors.
   pm->HandleGetHashError(now);
   EXPECT_EQ(7U, pm->gethash_error_count_);
   EXPECT_TRUE(pm->next_gethash_time_== now + TimeDelta::FromMinutes(480));
 }
 
 TEST_F(SafeBrowsingProtocolManagerTest, TestGetHashUrl) {
-  scoped_ptr<SafeBrowsingProtocolManager> pm(CreateProtocolManager(NULL));
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(CreateProtocolManager(NULL));
 
   EXPECT_EQ(
       "https://prefix.com/foo/gethash?client=unittest&appver=1.0&"
       "pver=3.0" +
           key_param_ + "&ext=0",
       pm->GetHashUrl(false).spec());
 
   pm->set_additional_query(kAdditionalQuery);
   EXPECT_EQ(
       "https://prefix.com/foo/gethash?client=unittest&appver=1.0&"
       "pver=3.0" +
           key_param_ + "&additional_query&ext=1",
       pm->GetHashUrl(true).spec());
 }
 
 TEST_F(SafeBrowsingProtocolManagerTest, TestUpdateUrl) {
-  scoped_ptr<SafeBrowsingProtocolManager> pm(CreateProtocolManager(NULL));
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(CreateProtocolManager(NULL));
 
   EXPECT_EQ(
       "https://prefix.com/foo/downloads?client=unittest&appver=1.0&"
       "pver=3.0" +
           key_param_ + "&ext=1",
       pm->UpdateUrl(true).spec());
 
   pm->set_additional_query(kAdditionalQuery);
   EXPECT_EQ(
       "https://prefix.com/foo/downloads?client=unittest&appver=1.0&"
       "pver=3.0" +
           key_param_ + "&additional_query&ext=0",
       pm->UpdateUrl(false).spec());
 }
 
 TEST_F(SafeBrowsingProtocolManagerTest, TestNextChunkUrl) {
-  scoped_ptr<SafeBrowsingProtocolManager> pm(CreateProtocolManager(NULL));
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(CreateProtocolManager(NULL));
 
   std::string url_partial = "localhost:1234/foo/bar?foo";
   std::string url_http_full = "http://localhost:1234/foo/bar?foo";
   std::string url_https_full = "https://localhost:1234/foo/bar?foo";
   std::string url_https_no_query = "https://localhost:1234/foo/bar";
 
   EXPECT_EQ("https://localhost:1234/foo/bar?foo",
             pm->NextChunkUrl(url_partial).spec());
   EXPECT_EQ("http://localhost:1234/foo/bar?foo",
             pm->NextChunkUrl(url_http_full).spec());
@@ skipping 18 matching lines @@
 class MockProtocolDelegate : public SafeBrowsingProtocolManagerDelegate {
  public:
   MockProtocolDelegate() {}
   ~MockProtocolDelegate() override {}
 
   MOCK_METHOD0(UpdateStarted, void());
   MOCK_METHOD1(UpdateFinished, void(bool));
   MOCK_METHOD0(ResetDatabase, void());
   MOCK_METHOD1(GetChunks, void(GetChunksCallback));
 
-  // gmock does not work with scoped_ptr<> at this time.  Add a local method to
+  // gmock does not work with std::unique_ptr<> at this time.  Add a local
+  // method to
   // mock, then call that from an override.  Beware of object ownership when
   // making changes here.
   MOCK_METHOD3(AddChunksRaw,
                void(const std::string& lists,
-                    const std::vector<scoped_ptr<SBChunkData>>& chunks,
+                    const std::vector<std::unique_ptr<SBChunkData>>& chunks,
                     AddChunksCallback));
-  void AddChunks(const std::string& list,
-                 scoped_ptr<std::vector<scoped_ptr<SBChunkData>>> chunks,
-                 AddChunksCallback callback) override {
+  void AddChunks(
+      const std::string& list,
+      std::unique_ptr<std::vector<std::unique_ptr<SBChunkData>>> chunks,
+      AddChunksCallback callback) override {
     AddChunksRaw(list, *chunks, callback);
   }
 
   // TODO(shess): Actually test this case somewhere.
   MOCK_METHOD1(DeleteChunksRaw,
                void(const std::vector<SBChunkDelete>& chunk_deletes));
   void DeleteChunks(
-      scoped_ptr<std::vector<SBChunkDelete>> chunk_deletes) override {
+      std::unique_ptr<std::vector<SBChunkDelete>> chunk_deletes) override {
     DeleteChunksRaw(*chunk_deletes);
   }
 };
 
 // |InvokeGetChunksCallback| is required because GMock's InvokeArgument action
 // expects to use operator(), and a Callback only provides Run().
 // TODO(cbentzel): Use ACTION or ACTION_TEMPLATE instead?
 void InvokeGetChunksCallback(
     const std::vector<SBListChunkRanges>& ranges,
     bool database_error,
     SafeBrowsingProtocolManagerDelegate::GetChunksCallback callback) {
   callback.Run(ranges, database_error, false);
 }
 
 // |HandleAddChunks| deletes the chunks and asynchronously invokes
 // |callback| since SafeBrowsingProtocolManager is not re-entrant at the time
 // this is called. This guarantee is part of the
 // SafeBrowsingProtocolManagerDelegate contract.
 void HandleAddChunks(
     const std::string& unused_list,
-    const std::vector<scoped_ptr<SBChunkData>>& chunks,
+    const std::vector<std::unique_ptr<SBChunkData>>& chunks,
     SafeBrowsingProtocolManagerDelegate::AddChunksCallback callback) {
   scoped_refptr<base::SingleThreadTaskRunner> task_runner(
       base::ThreadTaskRunnerHandle::Get());
   if (!task_runner.get())
     return;
   task_runner->PostTask(FROM_HERE, callback);
 }
 
 }  // namespace
 
 // Tests that the Update protocol will be skipped if there are problems
 // accessing the database.
 TEST_F(SafeBrowsingProtocolManagerTest, ProblemAccessingDatabase) {
   scoped_refptr<base::TestSimpleTaskRunner> runner(
       new base::TestSimpleTaskRunner());
   base::ThreadTaskRunnerHandle runner_handler(runner);
 
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     true)));
   EXPECT_CALL(test_delegate, UpdateFinished(false)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   EXPECT_TRUE(pm->IsUpdateScheduled());
 }
 
 // Tests the contents of the POST body when there are contents in the
 // local database. This is not exhaustive, as the actual list formatting
@@ skipping 16 matching lines @@
   ranges.push_back(range_unknown);
 
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     ranges,
                                     false)));
   EXPECT_CALL(test_delegate, UpdateFinished(true)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   // We should have an URLFetcher at this point in time.
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ASSERT_TRUE(url_fetcher);
   EXPECT_EQ(net::LOAD_DISABLE_CACHE, url_fetcher->GetLoadFlags());
@@ skipping 22 matching lines @@
   net::TestURLFetcherFactory url_fetcher_factory;
 
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     false)));
   EXPECT_CALL(test_delegate, UpdateFinished(true)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   // We should have an URLFetcher at this point in time.
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ValidateUpdateFetcherRequest(url_fetcher);
 
@@ skipping 26 matching lines @@
   net::TestURLFetcherFactory url_fetcher_factory;
 
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     false)));
   EXPECT_CALL(test_delegate, UpdateFinished(false)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   // We should have an URLFetcher at this point in time.
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ValidateUpdateFetcherRequest(url_fetcher);
 
@@ skipping 26 matching lines @@
   net::TestURLFetcherFactory url_fetcher_factory;
 
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     false)));
   EXPECT_CALL(test_delegate, UpdateFinished(true)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   // We should have an URLFetcher at this point in time.
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ValidateUpdateFetcherRequest(url_fetcher);
 
@@ skipping 26 matching lines @@
   net::TestURLFetcherFactory url_fetcher_factory;
 
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     false)));
   EXPECT_CALL(test_delegate, UpdateFinished(false)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   // We should have an URLFetcher at this point in time.
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ValidateUpdateFetcherRequest(url_fetcher);
 
@@ skipping 30 matching lines @@
   net::TestURLFetcherFactory url_fetcher_factory;
 
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     false)));
   EXPECT_CALL(test_delegate, UpdateFinished(false)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   // We should have an URLFetcher at this point in time.
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ValidateUpdateFetcherRequest(url_fetcher);
 
@@ skipping 26 matching lines @@
   net::TestURLFetcherFactory url_fetcher_factory;
 
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     false)));
   EXPECT_CALL(test_delegate, UpdateFinished(true)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   // We should have an URLFetcher at this point in time.
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ValidateUpdateFetcherRequest(url_fetcher);
 
@@ skipping 25 matching lines @@
   net::TestURLFetcherFactory url_fetcher_factory;
 
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     false)));
   EXPECT_CALL(test_delegate, UpdateFinished(false)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   // We should have an URLFetcher at this point in time.
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ValidateUpdateFetcherRequest(url_fetcher);
 
@@ skipping 27 matching lines @@
   net::TestURLFetcherFactory url_fetcher_factory;
 
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     false)));
   EXPECT_CALL(test_delegate, UpdateFinished(true)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   // We should have an URLFetcher at this point in time.
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ValidateUpdateFetcherRequest(url_fetcher);
 
@@ skipping 25 matching lines @@
   net::TestURLFetcherFactory url_fetcher_factory;
 
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     false)));
   EXPECT_CALL(test_delegate, UpdateFinished(true)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   // We should have an URLFetcher at this point in time.
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ValidateUpdateFetcherRequest(url_fetcher);
 
@@ skipping 24 matching lines @@
 
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     false)));
   EXPECT_CALL(test_delegate, ResetDatabase()).Times(1);
   EXPECT_CALL(test_delegate, UpdateFinished(true)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ValidateUpdateFetcherRequest(url_fetcher);
 
   // The update response is successful, and has a reset command.
@@ skipping 14 matching lines @@
   net::TestURLFetcherFactory url_fetcher_factory;
 
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     false)));
   EXPECT_CALL(test_delegate, UpdateFinished(true)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   // The update response contains a single redirect command.
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ValidateUpdateFetcherRequest(url_fetcher);
   url_fetcher->set_status(net::URLRequestStatus());
@@ skipping 26 matching lines @@
   net::TestURLFetcherFactory url_fetcher_factory;
 
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     false)));
   EXPECT_CALL(test_delegate, UpdateFinished(false)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   // The update response contains a single redirect command.
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ValidateUpdateFetcherRequest(url_fetcher);
   url_fetcher->set_status(net::URLRequestStatus());
@@ skipping 28 matching lines @@
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     false)));
   EXPECT_CALL(test_delegate, AddChunksRaw(kDefaultPhishList, _, _)).WillOnce(
       Invoke(HandleAddChunks));
   EXPECT_CALL(test_delegate, UpdateFinished(true)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   // The update response contains a single redirect command.
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ValidateUpdateFetcherRequest(url_fetcher);
   url_fetcher->set_status(net::URLRequestStatus());
@@ skipping 33 matching lines @@
   testing::StrictMock<MockProtocolDelegate> test_delegate;
   EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
   EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
       Invoke(testing::CreateFunctor(InvokeGetChunksCallback,
                                     std::vector<SBListChunkRanges>(),
                                     false)));
   EXPECT_CALL(test_delegate, AddChunksRaw(kDefaultPhishList, _, _)).
       WillRepeatedly(Invoke(HandleAddChunks));
   EXPECT_CALL(test_delegate, UpdateFinished(true)).Times(1);
 
-  scoped_ptr<SafeBrowsingProtocolManager> pm(
+  std::unique_ptr<SafeBrowsingProtocolManager> pm(
       CreateProtocolManager(&test_delegate));
 
   // Kick off initialization. This returns chunks from the DB synchronously.
   pm->ForceScheduleNextUpdate(TimeDelta());
   runner->RunPendingTasks();
 
   // The update response contains multiple redirect commands.
   net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
   ValidateUpdateFetcherRequest(url_fetcher);
   url_fetcher->set_status(net::URLRequestStatus());
@@ skipping 34 matching lines @@
 
   EXPECT_FALSE(pm->IsUpdateScheduled());
 
   // Invoke the AddChunksCallback to finish the update.
   runner->RunPendingTasks();
 
   EXPECT_TRUE(pm->IsUpdateScheduled());
 }
 
 }  // namespace safe_browsing