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

chrome/browser/extensions/api/declarative_content/declarative_content_is_bookmarked_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_is_bookmarked_condition_tracker.h"
 
+#include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/values_test_util.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.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 "chrome/test/base/testing_profile.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/scoped_group_bookmark_actions.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
@@ skipping 17 matching lines @@
   return ExtensionBuilder()
       .SetManifest(DictionaryBuilder()
                        .Set("name", "Test extension")
                        .Set("version", "1.0")
                        .Set("manifest_version", 2)
                        .Set("permissions", permissions.Build())
                        .Build())
       .Build();
 }
 
-scoped_ptr<DeclarativeContentIsBookmarkedPredicate> CreatePredicate(
+std::unique_ptr<DeclarativeContentIsBookmarkedPredicate> CreatePredicate(
     ContentPredicateEvaluator* evaluator,
     const Extension* extension,
     bool is_bookmarked) {
   std::string error;
-  scoped_ptr<DeclarativeContentIsBookmarkedPredicate> predicate =
+  std::unique_ptr<DeclarativeContentIsBookmarkedPredicate> predicate =
       DeclarativeContentIsBookmarkedPredicate::Create(
-          evaluator,
-          extension,
-          *base::test::ParseJson(is_bookmarked ? "true" : "false"),
-          &error);
+          evaluator, extension,
+          *base::test::ParseJson(is_bookmarked ? "true" : "false"), &error);
   EXPECT_EQ("", error);
   EXPECT_TRUE(predicate);
   EXPECT_EQ(is_bookmarked, predicate->is_bookmarked());
   return predicate;
 }
 
 }  // namespace
 
 using testing::HasSubstr;
 using testing::UnorderedElementsAre;
@@ skipping 72 matching lines @@
       result << "IsBookmarkedPredicate(false): expected "
              << (page_is_bookmarked ? "false" : "true") << " got "
              << (page_is_bookmarked ? "true" : "false");
     }
 
     return result;
   }
 
   Delegate delegate_;
   bookmarks::BookmarkModel* bookmark_model_;
-  scoped_ptr<DeclarativeContentIsBookmarkedConditionTracker> tracker_;
+  std::unique_ptr<DeclarativeContentIsBookmarkedConditionTracker> tracker_;
   scoped_refptr<Extension> extension_;
-  scoped_ptr<DeclarativeContentIsBookmarkedPredicate> is_bookmarked_predicate_;
-  scoped_ptr<DeclarativeContentIsBookmarkedPredicate>
+  std::unique_ptr<DeclarativeContentIsBookmarkedPredicate>
+      is_bookmarked_predicate_;
+  std::unique_ptr<DeclarativeContentIsBookmarkedPredicate>
       is_not_bookmarked_predicate_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeclarativeContentIsBookmarkedConditionTrackerTest);
 };
 
 
 // Tests that condition with isBookmarked requires "bookmarks" permission.
 TEST(DeclarativeContentIsBookmarkedPredicateTest,
      IsBookmarkedPredicateRequiresBookmarkPermissionPermission) {
   scoped_refptr<Extension> extension =
       CreateExtensionWithBookmarksPermission(false);
   std::string error;
-  scoped_ptr<DeclarativeContentIsBookmarkedPredicate> predicate =
+  std::unique_ptr<DeclarativeContentIsBookmarkedPredicate> predicate =
       DeclarativeContentIsBookmarkedPredicate::Create(
-          nullptr,
-          extension.get(),
-          *base::test::ParseJson("true"),
-          &error);
+          nullptr, extension.get(), *base::test::ParseJson("true"), &error);
   EXPECT_THAT(error, HasSubstr("requires 'bookmarks' permission"));
   EXPECT_FALSE(predicate);
 }
 
 // Tests an invalid isBookmarked value type.
 TEST(DeclarativeContentIsBookmarkedPredicateTest,
      WrongIsBookmarkedPredicateDatatype) {
   scoped_refptr<Extension> extension =
       CreateExtensionWithBookmarksPermission(true);
   std::string error;
-  scoped_ptr<DeclarativeContentIsBookmarkedPredicate> predicate =
+  std::unique_ptr<DeclarativeContentIsBookmarkedPredicate> predicate =
       DeclarativeContentIsBookmarkedPredicate::Create(
-          nullptr,
-          extension.get(),
-          *base::test::ParseJson("[]"),
-          &error);
+          nullptr, extension.get(), *base::test::ParseJson("[]"), &error);
   EXPECT_THAT(error, HasSubstr("invalid type"));
   EXPECT_FALSE(predicate);
 }
 
 // Tests isBookmark: true. Predicate state is checked in CreatePredicate().
 TEST(DeclarativeContentIsBookmarkedPredicateTest, IsBookmarkedPredicateTrue) {
   scoped_refptr<Extension> extension =
       CreateExtensionWithBookmarksPermission(true);
-  scoped_ptr<DeclarativeContentIsBookmarkedPredicate> predicate =
+  std::unique_ptr<DeclarativeContentIsBookmarkedPredicate> predicate =
       CreatePredicate(nullptr, extension.get(), true);
 }
 
 // Tests isBookmark: false. Predicate state is checked in CreatePredicate().
 TEST(DeclarativeContentIsBookmarkedPredicateTest, IsBookmarkedPredicateFalse) {
   scoped_refptr<Extension> extension =
       CreateExtensionWithBookmarksPermission(true);
-  scoped_ptr<DeclarativeContentIsBookmarkedPredicate> predicate =
+  std::unique_ptr<DeclarativeContentIsBookmarkedPredicate> predicate =
       CreatePredicate(nullptr, extension.get(), false);
 }
 
 // Tests that starting tracking for a WebContents that has a bookmarked URL
 // results in the proper IsUrlBookmarked state.
 TEST_F(DeclarativeContentIsBookmarkedConditionTrackerTest,
        BookmarkedAtStartOfTracking) {
-  scoped_ptr<content::WebContents> tab = MakeTab();
+  std::unique_ptr<content::WebContents> tab = MakeTab();
   LoadURL(tab.get(), GURL("http://bookmarked/"));
   EXPECT_TRUE(delegate_.evaluation_requests().empty());
 
   bookmark_model_->AddURL(bookmark_model_->other_node(), 0,
                           base::ASCIIToUTF16("title"),
                           GURL("http://bookmarked/"));
 
   tracker_->TrackForWebContents(tab.get());
   EXPECT_THAT(delegate_.evaluation_requests(), UnorderedElementsAre(tab.get()));
   EXPECT_TRUE(CheckPredicates(tab.get(), true));
 }
 
 // Tests that adding and removing bookmarks triggers evaluation requests for the
 // matching WebContents.
 TEST_F(DeclarativeContentIsBookmarkedConditionTrackerTest,
        AddAndRemoveBookmark) {
   // Create two tabs.
-  std::vector<scoped_ptr<content::WebContents>> tabs;
+  std::vector<std::unique_ptr<content::WebContents>> tabs;
   for (int i = 0; i < 2; ++i) {
     tabs.push_back(MakeTab());
     delegate_.evaluation_requests().clear();
     tracker_->TrackForWebContents(tabs.back().get());
     EXPECT_THAT(delegate_.evaluation_requests(),
                 UnorderedElementsAre(tabs.back().get()));
     EXPECT_TRUE(CheckPredicates(tabs.back().get(), false));
   }
 
   // Navigate the first tab to a URL that we will bookmark.
@@ skipping 24 matching lines @@
   EXPECT_THAT(delegate_.evaluation_requests(),
               UnorderedElementsAre(tabs[0].get()));
   EXPECT_TRUE(CheckPredicates(tabs[0].get(), false));
   EXPECT_TRUE(CheckPredicates(tabs[1].get(), false));
 }
 
 // Tests that adding and removing bookmarks triggers evaluation requests for the
 // matching WebContents.
 TEST_F(DeclarativeContentIsBookmarkedConditionTrackerTest, ExtensiveChanges) {
   // Create two tabs.
-  std::vector<scoped_ptr<content::WebContents>> tabs;
+  std::vector<std::unique_ptr<content::WebContents>> tabs;
   for (int i = 0; i < 2; ++i) {
     tabs.push_back(MakeTab());
     delegate_.evaluation_requests().clear();
     tracker_->TrackForWebContents(tabs.back().get());
     EXPECT_THAT(delegate_.evaluation_requests(),
                 UnorderedElementsAre(tabs.back().get()));
     EXPECT_TRUE(CheckPredicates(tabs.back().get(), false));
   }
 
   // Navigate the first tab to a URL that we will bookmark.
@@ skipping 82 matching lines @@
   // Bookmark two URLs.
   delegate_.evaluation_requests().clear();
   bookmark_model_->AddURL(bookmark_model_->other_node(), 0,
                           base::ASCIIToUTF16("title"),
                           GURL("http://bookmarked1/"));
   bookmark_model_->AddURL(bookmark_model_->other_node(), 0,
                           base::ASCIIToUTF16("title"),
                           GURL("http://bookmarked2/"));
 
   // Create two tabs.
-  std::vector<scoped_ptr<content::WebContents>> tabs;
+  std::vector<std::unique_ptr<content::WebContents>> tabs;
   for (int i = 0; i < 2; ++i) {
     tabs.push_back(MakeTab());
     delegate_.evaluation_requests().clear();
     tracker_->TrackForWebContents(tabs.back().get());
     EXPECT_THAT(delegate_.evaluation_requests(),
                 UnorderedElementsAre(tabs.back().get()));
     EXPECT_TRUE(CheckPredicates(tabs.back().get(), false));
   }
 
   // Navigate the first tab to one bookmarked URL.
@@ skipping 39 matching lines @@
   tracker_->OnWebContentsNavigation(tabs[0].get(),
                                     content::LoadCommittedDetails(),
                                     content::FrameNavigateParams());
   EXPECT_THAT(delegate_.evaluation_requests(),
               UnorderedElementsAre(tabs[0].get()));
   EXPECT_TRUE(CheckPredicates(tabs[0].get(), false));
   EXPECT_TRUE(CheckPredicates(tabs[1].get(), false));
 }
 
 }  // namespace extensions