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

chrome/browser/extensions/api/declarative_content/declarative_content_css_condition_tracker_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 "chrome/browser/extensions/api/declarative_content/declarative_content_css_condition_tracker.h"
 
+#include <memory>
 #include <tuple>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/test/values_test_util.h"
 #include "chrome/browser/extensions/api/declarative_content/content_predicate_evaluator.h"
 #include "chrome/browser/extensions/api/declarative_content/declarative_content_condition_tracker_test.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "extensions/common/extension_messages.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace extensions {
@@ skipping 25 matching lines @@
       return true;
     }
 
    private:
     int evaluation_requests_;
 
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // Creates a predicate with appropriate expectations of success.
-  scoped_ptr<const ContentPredicate> CreatePredicate(const std::string& value) {
-    scoped_ptr<const ContentPredicate> predicate;
+  std::unique_ptr<const ContentPredicate> CreatePredicate(
+      const std::string& value) {
+    std::unique_ptr<const ContentPredicate> predicate;
     CreatePredicateImpl(value, &predicate);
     return predicate;
   }
 
   // Expects an ExtensionMsg_WatchPages message in |sink| with |selectors| as
   // the param, after invoking |func|.
   template <class Func>
   void ExpectWatchPagesMessage(content::WebContents* tab,
                                const std::set<std::string>& selectors,
                                const Func& func) {
@@ skipping 27 matching lines @@
                                                      selectors);
     EXPECT_TRUE(GetMockRenderProcessHost(tab)->OnMessageReceived(page_change));
   }
 
   Delegate delegate_;
   DeclarativeContentCssConditionTracker tracker_;
 
  private:
   // This function exists to work around the gtest limitation that functions
   // with fatal assertions must return void.
-  void CreatePredicateImpl(
-      const std::string& value,
-      scoped_ptr<const ContentPredicate>* predicate) {
+  void CreatePredicateImpl(const std::string& value,
+                           std::unique_ptr<const ContentPredicate>* predicate) {
     std::string error;
     *predicate = tracker_.CreatePredicate(
         nullptr,
         *base::test::ParseJson(value),
         &error);
     EXPECT_EQ("", error);
     ASSERT_TRUE(*predicate);
   }
 
   DISALLOW_COPY_AND_ASSIGN(DeclarativeContentCssConditionTrackerTest);
 };
 
 TEST(DeclarativeContentCssPredicateTest, WrongCssDatatype) {
   std::string error;
-  scoped_ptr<DeclarativeContentCssPredicate> predicate =
+  std::unique_ptr<DeclarativeContentCssPredicate> predicate =
       DeclarativeContentCssPredicate::Create(
-          nullptr,
-          *base::test::ParseJson("\"selector\""),
-          &error);
+          nullptr, *base::test::ParseJson("\"selector\""), &error);
   EXPECT_THAT(error, HasSubstr("invalid type"));
   EXPECT_FALSE(predicate);
 }
 
 TEST(DeclarativeContentCssPredicateTest, CssPredicate) {
   std::string error;
-  scoped_ptr<DeclarativeContentCssPredicate> predicate =
+  std::unique_ptr<DeclarativeContentCssPredicate> predicate =
       DeclarativeContentCssPredicate::Create(
-          nullptr,
-          *base::test::ParseJson("[\"input\", \"a\"]"),
-          &error);
+          nullptr, *base::test::ParseJson("[\"input\", \"a\"]"), &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(predicate);
 
   EXPECT_THAT(predicate->css_selectors(), UnorderedElementsAre("input", "a"));
 }
 
 // Tests that adding and removing predicates causes a WatchPages message to be
 // sent.
 TEST_F(DeclarativeContentCssConditionTrackerTest, AddAndRemovePredicates) {
-  const scoped_ptr<content::WebContents> tab = MakeTab();
+  const std::unique_ptr<content::WebContents> tab = MakeTab();
   tracker_.TrackForWebContents(tab.get());
   EXPECT_EQ(0, delegate_.evaluation_requests());
 
   // Check that adding predicates sends a WatchPages message with the
   // corresponding selectors to the tab's RenderProcessHost.
-  std::vector<scoped_ptr<const ContentPredicate>> predicates;
+  std::vector<std::unique_ptr<const ContentPredicate>> predicates;
   predicates.push_back(CreatePredicate("[\"a\", \"div\"]"));
   predicates.push_back(CreatePredicate("[\"b\"]"));
   predicates.push_back(CreatePredicate("[\"input\"]"));
 
   // Add the predicates in two groups: (0, 1) and (2).
   std::map<const void*, std::vector<const ContentPredicate*>> predicate_groups;
   const void* const group1 = GeneratePredicateGroupID();
   predicate_groups[group1].push_back(predicates[0].get());
   predicate_groups[group1].push_back(predicates[1].get());
   const void* const group2 = GeneratePredicateGroupID();
@@ skipping 24 matching lines @@
   ExpectWatchPagesMessage(tab.get(), watched_selectors, [this, &group2]() {
     tracker_.StopTrackingPredicates(std::vector<const void*>(1, group2));
   });
   EXPECT_EQ(0, delegate_.evaluation_requests());
 }
 
 // Tests that adding and removing predicates that specify the same CSS selector
 // as an existing predicate does not cause a WatchPages message to be sent.
 TEST_F(DeclarativeContentCssConditionTrackerTest,
        AddAndRemovePredicatesWithSameSelectors) {
-  const scoped_ptr<content::WebContents> tab = MakeTab();
+  const std::unique_ptr<content::WebContents> tab = MakeTab();
   tracker_.TrackForWebContents(tab.get());
   EXPECT_EQ(0, delegate_.evaluation_requests());
 
   // Add the first predicate and expect a WatchPages message.
   std::string error;
-  scoped_ptr<const ContentPredicate> predicate1 = CreatePredicate("[\"a\"]");
+  std::unique_ptr<const ContentPredicate> predicate1 =
+      CreatePredicate("[\"a\"]");
 
   std::map<const void*, std::vector<const ContentPredicate*>> predicate_groups1;
   const void* const group1 = GeneratePredicateGroupID();
   predicate_groups1[group1].push_back(predicate1.get());
 
   std::set<std::string> watched_selectors;
   watched_selectors.insert("a");
   ExpectWatchPagesMessage(tab.get(), watched_selectors,
                           [this, &predicate_groups1]() {
     tracker_.TrackPredicates(predicate_groups1);
   });
   EXPECT_EQ(0, delegate_.evaluation_requests());
 
   // Add the second predicate specifying the same selector and expect no
   // WatchPages message.
-  scoped_ptr<const ContentPredicate> predicate2 = CreatePredicate("[\"a\"]");
+  std::unique_ptr<const ContentPredicate> predicate2 =
+      CreatePredicate("[\"a\"]");
 
   std::map<const void*, std::vector<const ContentPredicate*>> predicate_groups2;
   const void* const group2 = GeneratePredicateGroupID();
   predicate_groups2[group2].push_back(predicate2.get());
 
   ExpectNoWatchPagesMessage(tab.get(), [this, &predicate_groups2]() {
     tracker_.TrackPredicates(predicate_groups2);
   });
   EXPECT_EQ(0, delegate_.evaluation_requests());
 
   // Remove the first predicate and expect no WatchPages message.
   ExpectNoWatchPagesMessage(tab.get(), [this, group1]() {
     tracker_.StopTrackingPredicates(std::vector<const void*>(1, group1));
   });
   EXPECT_EQ(0, delegate_.evaluation_requests());
 
   // Remove the second predicate and expect an empty WatchPages message.
   ExpectWatchPagesMessage(tab.get(), std::set<std::string>(),
                           [this, group2]() {
     tracker_.StopTrackingPredicates(std::vector<const void*>(1, group2));
   });
   EXPECT_EQ(0, delegate_.evaluation_requests());
 }
 
 // Tests that WatchedPageChange messages result in evaluation requests, and
 // cause the appropriate predicates to evaluate to true.
 TEST_F(DeclarativeContentCssConditionTrackerTest, WatchedPageChange) {
   int expected_evaluation_requests = 0;
 
-  const scoped_ptr<content::WebContents> tab = MakeTab();
+  const std::unique_ptr<content::WebContents> tab = MakeTab();
   tracker_.TrackForWebContents(tab.get());
   EXPECT_EQ(expected_evaluation_requests, delegate_.evaluation_requests());
 
-  scoped_ptr<const ContentPredicate> div_predicate =
+  std::unique_ptr<const ContentPredicate> div_predicate =
       CreatePredicate("[\"div\"]");
-  scoped_ptr<const ContentPredicate> a_predicate = CreatePredicate("[\"a\"]");
+  std::unique_ptr<const ContentPredicate> a_predicate =
+      CreatePredicate("[\"a\"]");
 
   std::map<const void*, std::vector<const ContentPredicate*>> predicate_groups;
   const void* const group = GeneratePredicateGroupID();
   predicate_groups[group].push_back(div_predicate.get());
   predicate_groups[group].push_back(a_predicate.get());
   tracker_.TrackPredicates(predicate_groups);
   EXPECT_EQ(expected_evaluation_requests, delegate_.evaluation_requests());
 
   // Check that receiving an OnWatchedPageChange message from the tab results in
   // a request for condition evaluation.
   const std::vector<std::string> matched_selectors(1, "div");
   SendOnWatchedPageChangeMessage(tab.get(), matched_selectors);
   EXPECT_EQ(++expected_evaluation_requests, delegate_.evaluation_requests());
 
   // Check that only the div predicate matches.
   EXPECT_TRUE(tracker_.EvaluatePredicate(div_predicate.get(), tab.get()));
   EXPECT_FALSE(tracker_.EvaluatePredicate(a_predicate.get(), tab.get()));
   EXPECT_EQ(expected_evaluation_requests, delegate_.evaluation_requests());
 
   tracker_.StopTrackingPredicates(std::vector<const void*>(1, group));
 }
 
 // Tests in-page and non-in-page navigations. Only the latter should reset
 // matching selectors and result in an evaluation request.
 TEST_F(DeclarativeContentCssConditionTrackerTest, Navigation) {
   DeclarativeContentCssConditionTracker tracker(&delegate_);
 
   int expected_evaluation_requests = 0;
 
-  const scoped_ptr<content::WebContents> tab = MakeTab();
+  const std::unique_ptr<content::WebContents> tab = MakeTab();
   tracker_.TrackForWebContents(tab.get());
   EXPECT_EQ(expected_evaluation_requests, delegate_.evaluation_requests());
 
-  scoped_ptr<const ContentPredicate> predicate = CreatePredicate("[\"div\"]");
+  std::unique_ptr<const ContentPredicate> predicate =
+      CreatePredicate("[\"div\"]");
   std::map<const void*, std::vector<const ContentPredicate*>> predicate_groups;
   const void* const group = GeneratePredicateGroupID();
   predicate_groups[group].push_back(predicate.get());
   tracker_.TrackPredicates(predicate_groups);
   EXPECT_EQ(expected_evaluation_requests, delegate_.evaluation_requests());
 
   // Set up the tab to have a matching selector.
   const std::vector<std::string> matched_selectors(1, "div");
   SendOnWatchedPageChangeMessage(tab.get(), matched_selectors);
   EXPECT_EQ(++expected_evaluation_requests, delegate_.evaluation_requests());
@@ skipping 15 matching lines @@
     details.is_in_page = false;
     content::FrameNavigateParams params;
     tracker_.OnWebContentsNavigation(tab.get(), details, params);
     EXPECT_FALSE(tracker_.EvaluatePredicate(predicate.get(), tab.get()));
     EXPECT_EQ(++expected_evaluation_requests, delegate_.evaluation_requests());
   }
 }
 
 // https://crbug.com/497586
 TEST_F(DeclarativeContentCssConditionTrackerTest, WebContentsOutlivesTracker) {
-  const scoped_ptr<content::WebContents> tab = MakeTab();
+  const std::unique_ptr<content::WebContents> tab = MakeTab();
 
   {
     DeclarativeContentCssConditionTracker tracker(&delegate_);
     tracker_.TrackForWebContents(tab.get());
   }
 }
 
 }  // namespace extensions