Convert //components/[f-n]* from scoped_ptr to std::unique_ptr

components/ntp_snippets/ntp_snippets_service_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 "components/ntp_snippets/ntp_snippets_service.h"
 
+#include <memory>
+
 #include "base/json/json_reader.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/ntp_snippets/ntp_snippet.h"
 #include "components/ntp_snippets/ntp_snippets_fetcher.h"
 #include "components/ntp_snippets/ntp_snippets_scheduler.h"
 #include "components/prefs/testing_pref_service.h"
@@ skipping 69 matching lines @@
   json_str[pos + 1] = 'x';
   return json_str;
 }
 
 void ParseJson(
     bool expect_success,
     const std::string& json,
     const ntp_snippets::NTPSnippetsService::SuccessCallback& success_callback,
     const ntp_snippets::NTPSnippetsService::ErrorCallback& error_callback) {
   base::JSONReader json_reader;
-  scoped_ptr<base::Value> value = json_reader.ReadToValue(json);
+  std::unique_ptr<base::Value> value = json_reader.ReadToValue(json);
   bool success = !!value;
   EXPECT_EQ(expect_success, success);
   if (value) {
     success_callback.Run(std::move(value));
   } else {
     error_callback.Run(json_reader.GetErrorMessage());
   }
 }
 
 class MockScheduler : public NTPSnippetsScheduler {
@@ skipping 27 matching lines @@
   void CreateSnippetsServiceEnabled(bool enabled) {
     scheduler_.reset(new MockScheduler);
     scoped_refptr<base::SingleThreadTaskRunner> task_runner(
         base::ThreadTaskRunnerHandle::Get());
     scoped_refptr<net::TestURLRequestContextGetter> request_context_getter =
         new net::TestURLRequestContextGetter(task_runner.get());
 
     service_.reset(new NTPSnippetsService(
         pref_service_.get(), nullptr, task_runner, std::string("fr"),
         scheduler_.get(),
-        make_scoped_ptr(new NTPSnippetsFetcher(
+        base::WrapUnique(new NTPSnippetsFetcher(
             task_runner, std::move(request_context_getter), true)),
         base::Bind(&ParseJson, true)));
     if (enabled)
       EXPECT_CALL(*scheduler_, Schedule(_, _, _, _));
     else
       EXPECT_CALL(*scheduler_, Unschedule());
     service_->Init(enabled);
   }
 
  protected:
   NTPSnippetsService* service() { return service_.get(); }
 
   void LoadFromJSONString(const std::string& json) {
     service_->OnSnippetsDownloaded(json, std::string());
   }
 
   void SetExpectJsonParseSuccess(bool expect_success) {
     service_->parse_json_callback_ = base::Bind(&ParseJson, expect_success);
   }
 
  private:
   base::MessageLoop message_loop_;
-  scoped_ptr<TestingPrefServiceSimple> pref_service_;
-  scoped_ptr<NTPSnippetsService> service_;
-  scoped_ptr<MockScheduler> scheduler_;
+  std::unique_ptr<TestingPrefServiceSimple> pref_service_;
+  std::unique_ptr<NTPSnippetsService> service_;
+  std::unique_ptr<MockScheduler> scheduler_;
 
   DISALLOW_COPY_AND_ASSIGN(NTPSnippetsServiceTest);
 };
 
 class NTPSnippetsServiceDisabledTest : public NTPSnippetsServiceTest {
  public:
   void CreateSnippetsService() override {
     CreateSnippetsServiceEnabled(false);
   }
 };
@@ skipping 195 matching lines @@
 }
 
 TEST_F(NTPSnippetsServiceTest, RemoveExpiredContent) {
   std::string json_str(GetTestExpiredJson());
 
   LoadFromJSONString(json_str);
   EXPECT_EQ(service()->size(), 0u);
 }
 
 }  // namespace ntp_snippets