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

chrome/browser/extensions/api/declarative_content/chrome_content_rules_registry_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/extensions/api/declarative_content/chrome_content_rules_registry.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/test/values_test_util.h"
 #include "chrome/browser/extensions/api/declarative_content/content_predicate.h"
 #include "chrome/browser/extensions/api/declarative_content/content_predicate_evaluator.h"
 #include "chrome/browser/extensions/test_extension_environment.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/frame_navigate_params.h"
 #include "extensions/common/extension.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 25 matching lines @@
   explicit TestPredicateEvaluator(ContentPredicateEvaluator::Delegate* delegate)
       : delegate_(delegate),
         contents_for_next_operation_evaluation_(nullptr),
         next_evaluation_result_(false) {
   }
 
   std::string GetPredicateApiAttributeName() const override {
     return "test_predicate";
   }
 
-  scoped_ptr<const ContentPredicate> CreatePredicate(
+  std::unique_ptr<const ContentPredicate> CreatePredicate(
       const Extension* extension,
       const base::Value& value,
       std::string* error) override {
     RequestEvaluationIfSpecified();
-    return make_scoped_ptr(new TestPredicate(this));
+    return base::WrapUnique(new TestPredicate(this));
   }
 
   void TrackPredicates(
       const std::map<const void*,
           std::vector<const ContentPredicate*>>& predicates) override {
     RequestEvaluationIfSpecified();
   }
 
   void StopTrackingPredicates(
       const std::vector<const void*>& predicate_groups) override {
@@ skipping 38 matching lines @@
   }
 
   ContentPredicateEvaluator::Delegate* delegate_;
   content::WebContents* contents_for_next_operation_evaluation_;
   mutable bool next_evaluation_result_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPredicateEvaluator);
 };
 
 // Create the test evaluator and set |evaluator| to its pointer.
-std::vector<scoped_ptr<ContentPredicateEvaluator>> CreateTestEvaluator(
+std::vector<std::unique_ptr<ContentPredicateEvaluator>> CreateTestEvaluator(
     TestPredicateEvaluator** evaluator,
     ContentPredicateEvaluator::Delegate* delegate) {
-  std::vector<scoped_ptr<ContentPredicateEvaluator>> evaluators;
+  std::vector<std::unique_ptr<ContentPredicateEvaluator>> evaluators;
   *evaluator = new TestPredicateEvaluator(delegate);
-  evaluators.push_back(scoped_ptr<ContentPredicateEvaluator>(*evaluator));
+  evaluators.push_back(std::unique_ptr<ContentPredicateEvaluator>(*evaluator));
   return evaluators;
 }
 
 }  // namespace
 
 class DeclarativeChromeContentRulesRegistryTest : public testing::Test {
  public:
   DeclarativeChromeContentRulesRegistryTest() {}
 
  protected:
   TestExtensionEnvironment* env() { return &env_; }
 
  private:
   TestExtensionEnvironment env_;
 
   DISALLOW_COPY_AND_ASSIGN(DeclarativeChromeContentRulesRegistryTest);
 };
 
 TEST_F(DeclarativeChromeContentRulesRegistryTest, ActiveRulesDoesntGrow) {
   TestPredicateEvaluator* evaluator = nullptr;
   scoped_refptr<ChromeContentRulesRegistry> registry(
       new ChromeContentRulesRegistry(env()->profile(), nullptr,
                                      base::Bind(&CreateTestEvaluator,
                                                 &evaluator)));
 
   EXPECT_EQ(0u, registry->GetActiveRulesCountForTesting());
 
-  scoped_ptr<content::WebContents> tab = env()->MakeTab();
+  std::unique_ptr<content::WebContents> tab = env()->MakeTab();
   registry->MonitorWebContentsForRuleEvaluation(tab.get());
   registry->DidNavigateMainFrame(tab.get(), content::LoadCommittedDetails(),
                                  content::FrameNavigateParams());
   EXPECT_EQ(0u, registry->GetActiveRulesCountForTesting());
 
   // Add a rule.
   linked_ptr<api::events::Rule> rule(new api::events::Rule);
   api::events::Rule::Populate(
       *base::test::ParseJson(
           "{\n"
@@ skipping 32 matching lines @@
   evaluator->RequestImmediateEvaluation(tab.get(), true);
   EXPECT_EQ(1u, registry->GetActiveRulesCountForTesting());
 
   evaluator->RequestEvaluationOnNextOperation(tab.get(), false);
   registry->DidNavigateMainFrame(tab.get(), content::LoadCommittedDetails(),
                                  content::FrameNavigateParams());
   EXPECT_EQ(0u, registry->GetActiveRulesCountForTesting());
 }
 
 }  // namespace extensions