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

chrome/browser/extensions/api/declarative_content/declarative_content_is_bookmarked_condition_tracker.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 "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/extensions/api/declarative_content/content_constants.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/common/permissions/permissions_data.h"
 
@@ skipping 18 matching lines @@
 
 DeclarativeContentIsBookmarkedPredicate::
 ~DeclarativeContentIsBookmarkedPredicate() {
 }
 
 bool DeclarativeContentIsBookmarkedPredicate::IsIgnored() const {
   return !HasBookmarkAPIPermission(extension_.get());
 }
 
 // static
-scoped_ptr<DeclarativeContentIsBookmarkedPredicate>
+std::unique_ptr<DeclarativeContentIsBookmarkedPredicate>
 DeclarativeContentIsBookmarkedPredicate::Create(
     ContentPredicateEvaluator* evaluator,
     const Extension* extension,
     const base::Value& value,
     std::string* error) {
   bool is_bookmarked = false;
   if (value.GetAsBoolean(&is_bookmarked)) {
     if (!HasBookmarkAPIPermission(extension)) {
       *error = kIsBookmarkedRequiresBookmarkPermission;
-      return scoped_ptr<DeclarativeContentIsBookmarkedPredicate>();
+      return std::unique_ptr<DeclarativeContentIsBookmarkedPredicate>();
     } else {
-      return make_scoped_ptr(
-          new DeclarativeContentIsBookmarkedPredicate(evaluator, extension,
-                                                      is_bookmarked));
+      return base::WrapUnique(new DeclarativeContentIsBookmarkedPredicate(
+          evaluator, extension, is_bookmarked));
     }
   } else {
     *error = base::StringPrintf(kInvalidTypeOfParameter,
                                 declarative_content_constants::kIsBookmarked);
-    return scoped_ptr<DeclarativeContentIsBookmarkedPredicate>();
+    return std::unique_ptr<DeclarativeContentIsBookmarkedPredicate>();
   }
 }
 
 ContentPredicateEvaluator*
 DeclarativeContentIsBookmarkedPredicate::GetEvaluator() const {
   return evaluator_;
 }
 
 DeclarativeContentIsBookmarkedPredicate::
 DeclarativeContentIsBookmarkedPredicate(
@@ skipping 85 matching lines @@
 
 DeclarativeContentIsBookmarkedConditionTracker::
 ~DeclarativeContentIsBookmarkedConditionTracker() {
 }
 
 std::string DeclarativeContentIsBookmarkedConditionTracker::
 GetPredicateApiAttributeName() const {
   return declarative_content_constants::kIsBookmarked;
 }
 
-scoped_ptr<const ContentPredicate>
+std::unique_ptr<const ContentPredicate>
 DeclarativeContentIsBookmarkedConditionTracker::CreatePredicate(
     const Extension* extension,
     const base::Value& value,
     std::string* error) {
   return DeclarativeContentIsBookmarkedPredicate::Create(this, extension, value,
                                                          error);
 }
 
 // We don't have any centralized state to update for new predicates, so we don't
 // need to take any action here or in StopTrackingPredicates().
@@ skipping 97 matching lines @@
   per_web_contents_tracker_.erase(contents);
 }
 
 void DeclarativeContentIsBookmarkedConditionTracker::
 UpdateAllPerWebContentsTrackers() {
   for (const auto& web_contents_tracker_pair : per_web_contents_tracker_)
     web_contents_tracker_pair.second->UpdateState(false);
 }
 
 }  // namespace extensions